An AI agent is not just a chatbot that answers a question. It's a system that can act in the world: it opens a browser, reads and writes files, runs code, calls services through an API. And, more importantly, it works in cycles - it makes a plan, executes a step, sees what came out, adjusts, takes another step. It keeps going until it reaches a result or decides it's stuck. The difference from an ordinary assistant isn't necessarily in the underlying brain - the same language model can be both a chatbot and an agent - but in how many tools it has at its disposal and how many iterations it's allowed between you and the final result.
All the examples I discuss below - Claude Cowork, Claude Code, OpenClaw, Hermes Agent - fit this definition. They are agents. The question of this essay is not whether they are agents, but what kind of agents they are.
There's a subtle detail that separates two families of AI agents, and once you notice it you can't unsee it: whose heartbeat is it?
With a partner agent - like Claude Cowork, or Claude Code in programming work - the heartbeat is yours. You start a conversation, the agent responds, you react, the agent iterates. Between your prompts, the agent doesn't exist in time: it doesn't run in the background, it doesn't decide on its own what the next thing to do is, it doesn't start up again until you call it. The agent's tempo is your tempo. When you stop, it stops too.
With an autonomous agent - OpenClaw, Hermes Agent, and the whole ecosystem growing around them - the heartbeat is the agent's. You launch it once, give it an initial intent, and from there the agent has its own clock: it decides when to check something, when to act, when to call other tools, when to update its memory. It keeps existing in time even after you close your laptop. It beats on its own.
The heartbeat isn't just a metaphor. With an autonomous agent there literally is a process running on a server - a loop that, periodically (every few seconds, minutes, or whenever an event happens), tells the agent "check, decide, act." That loop is the heartbeat: a technical piece, configurable, measurable. With a partner agent that loop simply doesn't exist - nothing runs between your prompts.
The difference seems small. It isn't.
An agent that has its own heartbeat will inevitably develop its own trajectory. With every decision made without you, its context shifts a little away from yours. By the hundredth decision, the agent has moved away from the intent you started it with. The longer it runs, the more so.
And here's the nuance many people miss: this isn't a bug, it's a feature. An autonomous agent has to break away, otherwise it wouldn't be autonomous. The breaking away is precisely the sign that it's working. An OpenClaw that asked "are you sure?" at every step would no longer be OpenClaw - it would be a badly configured Claude Code. A Hermes that didn't refine its own internal model of the world would no longer be Hermes.
What you see when you let an autonomous agent run is not "AI doing what you asked it to." It's a new being, started from a seed you planted, which then develops on its own. Beautiful, fascinating, useful in many contexts - but a different species of relationship than symbiosis.
Because that's what a partner agent does: symbiosis. You bring the intent, the agent brings its capabilities, and the dialogue builds something that exists neither in you nor in it - it exists between you. And because the heartbeat stays yours, what comes out at the end is recognizable as yours. Not another self that continued without you, but an extended self that thought with AI alongside.
These are two philosophies of leverage.
The autonomous agent offers leverage through multiplication: you start ten agents, each with its own heartbeat, each running in parallel, each diverging in its own direction. You gain capacity, scale, a presence in time that exceeds your own. You lose recognizability - in the end, what came out is something that happened without you.
The partner agent offers leverage through amplification: a single heartbeat, yours, but each of your beats moves more than it would on its own. You gain clarity, depth, sustained intent. You lose parallelism - the agent doesn't work while you sleep.
Personally, I work almost exclusively on the second axis, with Claude Code and Claude Cowork. Not because the first doesn't exist or is illegitimate - it's a real practice, done by serious people, and for many contexts it's exactly the right thing. To build an entire web application from scratch without caring exactly what comes out at the end, for crypto trading with direct wallet access, or - in theory, though I don't yet know how widespread it is in practice - to work as a freelancer in your place, the first axis is clearly better. But where I do valuable work - thinking with someone, writing, deciding, learning - I want the heartbeat to stay mine. I want what comes out at the end to be recognizable as mine, because every step started from me.
This isn't a hierarchy. They're two species of tools, for two species of work.
It's good to know which one you're using when.