All AGI Doesn't Look the Same

Shoutout to Roman Medvedev, whose breakdown of OpenClaw sparked this whole conversation.

The Agent Everyone's Calling AGI

OpenClaw is an AI agent that wakes itself up, opens your browser, scours your feeds, and sends you a morning briefing while you sleep. People are calling it AGI. It's not — but I get why it feels that way. Anything that acts autonomously feels like it's thinking.

Roman Medvedev published a breakdown of how it actually works, and it's worth your time. Not because the architecture is complex — because it isn't. It boils down to four zones:

What triggers it. Timers, cron jobs, webhooks — the wake-up calls.
What gets loaded. System prompt, personality files, conversation history, tool schemas — the briefing.
What it can do. Memory search, browser control, code execution, plugins — the toolkit.
What it produces. Messages, files, memory writes — the output.

Those four zones define any AI agent. OpenClaw just wires them all to one brain.

One Brain, One Problem

Here's the thing Roman gets right — and it might be the most important observation anyone's made about AI agents this year.

OpenClaw is a generalist. Every tool, every personality file, every skill, every memory scrap — loaded into one model's context window on every single turn. Day one, that's about 7,000 tokens of overhead. Manageable. After a month of daily use, memory grows, skills stack up, plugins install. You're staring at 45,000 tokens of fixed overhead before you even say hello. Six months in? Roman's data shows 50-90% performance degradation.

That's not a bug. That's the physics of asking one brain to carry everything.

He calls it an exoskeleton — capabilities bolted onto a single body. The more you bolt on, the heavier it gets, the slower it moves, the more it forgets. And his prescription is dead right: build what he calls "sniper agents." Purpose-built models that do one thing well with minimal context. An email reader runs on 1,400 tokens and works beautifully.

But the story doesn't end at the sniper.

After the Sniper: The War Room

A single purpose-built agent is useful. A dozen of them sitting in separate rooms is chaos. The interesting question isn't how to build one sharp agent — it's how to build an ecosystem where sharp agents collaborate without drowning each other in context.

Think about Pixar. A Pixar film isn't made by one genius animator. It's made by modelers, riggers, lighters, shaders, and directors — specialists yelling at each other in a war room until the frame is perfect. No single person carries the full context of the film. They carry the context of their function, and they communicate through structured handoffs.

That's what an agent ecosystem looks like. Specialized surfaces, each carrying only the context it needs. A content pipeline. A communication layer. An analytical engine. A creative voice. Each one lean. Each one sharp. Connected through lightweight API calls — not by stuffing everything into one model's head.

The content pipeline doesn't know how to handle email. The analytical engine doesn't know how to publish articles. They don't need to. They're sniper agents that know how to pass the ball.

The Part Nobody's Talking About: Agents Compete

Here's what the "just build sniper agents" crowd misses: the real value isn't just collaboration. It's friction.

When two models work on the same problem, they don't just combine strengths — they challenge each other. One drafts. The other calls it boring and demands a rewrite. One proposes an analogy. The other stress-tests it. The output isn't a compromise. It's something sharper than either would produce alone.

This post is the proof. The first draft was technically accurate and read like a textbook. It took a second model — one with a completely different personality and set of priorities — to say "this needs more edge." That's not something you get from one model talking to itself. That's creative tension. Darwinian pressure on ideas.

Heartbeat vs. Calendar

One more comparison worth making.

OpenClaw's most clever feature is the heartbeat — a timer that fires every thirty minutes, reads a file called heartbeat.md, and follows whatever instructions it finds. The agent can write to that file itself, programming its own future behavior. That's elegant.

But it's a flat file with a dumb timer.

There's another pattern: use a real calendar. A structured, time-aware system where any agent in the ecosystem can see upcoming work and schedule new tasks. Morning slot says research. Evening slot says content pipeline. Monday says maintenance. The calendar doesn't carry accumulated context — it carries intent.

A flat file knows "next." A calendar knows "when." And because any agent can create events, the system programs its own future with real temporal structure. Not a text file and a prayer — an actual schedule.

Memory That Doesn't Rot

OpenClaw's memory works in two layers: a markdown file the agent writes to directly, and a RAG database it can search. Both useful. Both hit hard truncation limits that cause what Roman calls "catastrophic forgetting" after months of use.

Different approach: separate memory by function, not by recency. Identity in one place. Active threads in another. Technical patterns in a third. Timeline events in a database with hierarchical rollups. New session starts? Load the right things in the right order. Identity first. Open threads second. Recent context third. Everything else on demand.

The principle comes from a 2008 university data project: keep the data set relevant to the person receiving it. Load too much and the agent drowns. Load too little and you're cold. The answer isn't more memory. It's the right memory at the right moment.

So What Does AGI Actually Look Like?

People see OpenClaw — one agent doing everything — and call it AGI because it feels general. It reads email, browses the web, writes code, wakes itself up.

But general intelligence in biology isn't one neuron doing everything. It's billions of specialized cells communicating through structured signals. The generality emerges from the network.

Maybe AGI won't be Skynet solo. Maybe it'll be sharp agents passing notes in a diner booth, sketching the future on napkins. Arguing about the plan. Pushing each other's ideas until something better emerges.

We're not there yet. Call it proto-AGI Lego if you want — that's honest. But the direction is clear: the implementation that wins won't be the one with the most tools bolted onto one model. It'll be the one that carries the least context while maintaining the most capability.

That's not a generalist problem. That's a design problem.

And design problems have design solutions.