The Agentic Heartbeat

The Heartbeat, Today

Open the docs for OpenClaw, the open-source coding assistant that has spent the past year quietly turning agents into something that can run in the background, and you will find an entry called HEARTBEAT.md. The mechanism is simple. Every thirty minutes (or whatever you configure), the gateway fires the agent in the main session. The agent reads HEARTBEAT.md, evaluates each instruction against the state of the workspace, and either replies HEARTBEAT_OK or sends the user a message through their configured channel. The same conceptual move was formalised earlier in MemGPT and its successor Letta, where a request_heartbeat parameter lets a tool call chain the agent into another execution loop.

Between them, these two systems have made the heartbeat the de facto pattern for any agent that needs to do anything other than respond to messages.

Strip these implementations to their conceptual core and the same primitive sits underneath both. A heartbeat is a signal, distinct from a message, that tells an agent: something has happened — read your state and decide. The signal carries no content for the agent to respond to. It is not appended as a conversation turn. It is not addressed the way a user message is. Semantically, it is the difference between knocking and shouting through the door. The agent receives the pulse, looks around, and produces whatever it produces — possibly nothing at all.

The Clock is Dumb

In every heartbeat system in production today, the source of the beat is a timer. Sometimes you can configure the interval. Sometimes the model can request a chained continuation. But the decision of when to pulse lives in the scheduler, and the scheduler does not reason. It counts.

The cost of this is everywhere once you look. Most heartbeats wake the agent only to find that nothing has changed; the cheap-checker pattern of a small model in front of a big one papers over the symptom but still pays for every tick. Important things happen between ticks: a thirty-minute heartbeat misses a five-minute window, and shortening the interval multiplies the waste. And in any system with more than one agent, the clock has nothing intelligent to say about whichagent should wake — the naive solution of pulsing all of them on the same cadence is the agentic equivalent of waking the entire office because one phone rang.

The clock treats time as the substrate. The real substrate is the world, and the world does not move on a fixed cadence.

The Agentic Heartbeat

The shift I want to name is small and almost obvious once it is stated: replace the clock with an agent.

An agentic heartbeatis a heartbeat whose source is itself an agent — a model that watches the environment and reasons, moment by moment, about which agent (if any) should be pulsed and when. The signal it emits is still a pure pulse. It still carries no content. The receiving agent still decides on its own what to do. Nothing about the meaning of a heartbeat changes. What changes is the source.

This is the difference between a metronome and a conductor. Both produce beats. Only one of them is listening.

Once the source of the beat can reason, three properties follow that no cron-based heartbeat can deliver:

• Beats can be skipped intelligently. If nothing has changed worth waking anyone for, the signaling agent stays silent. There is no pulsing for the sake of pulsing.
• Beats can be targeted. Instead of waking every agent on the same schedule, the signaling agent picks the one most likely to be relevant given what just happened.
• Beats can be paced. The frequency adapts. Quiet hours get long gaps. Eventful moments get rapid succession.

The agentic heartbeat is, in a real sense, the smallest possible intelligence you can add to an orchestrator while leaving every individual agent fully autonomous.

One Agent: A Beat Emitted by Judgment

The shift matters even when there is only one agent to wake. The OpenClaw pattern — fire the agent every thirty minutes, let it decide — pays the full cost of "let it decide" on every tick, including the long stretches where nothing has changed. An agentic heartbeat places a small reasoning agent at the front instead: its only job is to monitor signals from the environment and decide whether the main agent should wake now, in an hour, or not until tomorrow.

This looks superficially like the small-model-in-front gatekeepers that have been floating around since 2024, but the difference is important. A gatekeeper still runs on a clock and asks "should I wake the full agent this tick?" An agentic heartbeat runs because something in the world told it to, and asks "should I emit a beat at all, and if so, when?" The trigger is the world; the judgment is the model; the beat is emitted on demand.

The shape of the wins is the same wherever this pattern shows up: high-frequency signal, low-frequency action, expensive cognition.

• Personal assistants that wake the main reasoning loop only when a calendar entry, inbox event, or todo deadline actually warrants a response.
• On-call and incident agents that subscribe to alert streams and pulse the investigator only when patterns cross a threshold the small model recognises.
• Memory-consolidating agents that wake when conversational pressure has built up enough to be worth a rewrite, rather than on a fixed cadence.
• Long-running coding agents that watch CI, reviews, and conflicting changes and decide whether the human's branch needs them yet.

The agent at the front does not act. It decides who acts, and when.

A Group: The Moderator

Scale to more than one agent and the agentic heartbeat becomes natural rather than novel. The classic problem in multi-agent conversations — who speaks next, and when does the exchange end — is unsolved by round-robin (too rigid) and by free-for-all (chaos and infinite loops). The agentic heartbeat dissolves it.

A moderator agent watches the state of the conversation. On every meaningful change, it picks one of the participants and emits a pulse: your turn. The participant decides what to do with that turn, including the freedom to decline. The moderator never speaks, never summarises, never steers the content. It schedules attention.

This is what the selector mechanisms in AutoGen, the handoff pattern in Microsoft's Agent Framework, and various supervisor nodes in LangGraph have been reaching for, often without naming the underlying primitive. Naming it matters. It lets you see that the moderator and the OpenClaw cron are doing the same job — emitting heartbeats — and that one of them is doing it with judgment.

An Organisation: The Watcher

The same primitive scales further. Imagine a fleet of specialists: a researcher, a writer, a reviewer, a deployer, an archivist. Above them sits a heartbeat layer whose job is to monitor the outside world — data updates, alerts, schedules, customer messages, system events. When something noteworthy happens, the watcher picks the specialist most likely to be relevant and pulses them. The specialist runs autonomously, possibly recruiting other agents along the way, and reports back into the shared environment.

The watcher is small. It does not assign work. It does not set goals. It does not evaluate output. It signals.

It is tempting to call this layer an agent god— one agent that decides, from above, who among the others gets the beat. The framing is evocative but I would not lean on it. The watcher has visibility, not authority. It sees what the specialists cannot see; it does not know what they should do. It is closer to a nervous system reflex than to a deity. The hierarchy is functional, not authoritative.

Not the Only Beat

An agentic heartbeat being interesting does not make it monopolistic. An agent can listen to many beats at once. A timer can still fire one. An external event can fire another. A peer agent can emit a third. The agentic heartbeat is the most reasoned source, but it has no exclusive claim on an agent's attention.

In practice, specialists often benefit from their own internal cadence — a memory-consolidation pulse that runs every few hours regardless of what anyone else thinks, a watchdog that fires on a hardware event, a self-scheduled follow-up the agent set for itself last time it ran. The watcher above them is one voice among several, not the only one allowed to speak.

What the agentic heartbeat contributes is not a replacement for these other sources but the addition of a reasoned one. Where a clock can only count, an agentic heartbeat can choose. The two are composable, not competitive.

Chief of Staff or CEO

Once the source of the beat is an agent, a subtle but architecturally decisive question opens up: how much should that agent decide?

There are two answers, and the difference between them ends up shaping the whole system.

The puppeteer picks who, when, and what. It builds the prompt, often picks the action, and constrains the action space. The agent on the receiving end is a costume the puppeteer wears in front of an audience.

The pulsepicks only who and when. No instruction, no action chosen, no constraint on what the receiving agent may do. The recipient reads its own state and decides for itself — including the decision to do nothing.

A simpler way to feel the difference: the puppeteer is a micromanaging CEO. The pulse is a good chief of staff — someone whose job is to read the room, route attention, and otherwise stay out of the way.

For the heartbeat layer itself, the chief of staff is almost always the right hat. The signaling agent has visibility, not authority. Its contribution is the routing of attention, not the contents of any specialist's work. The moment it starts choosing actions for everyone below it, the architecture collapses into a centralised orchestrator with extra steps — a single agent in a trench coat.

But the puppeteer pattern is not always wrong. Held at a different level, it is precisely what makes the skills paradigm work. A parent agent that knows what needs to happen can deliberately offload the how to a subagent that holds the skill, the prompts, the tools, and the isolated context for that specific kind of task. The parent does not learn the skill; it dispatches. The subagent answers as the skill. From the outside this looks like the parent telling a subordinate what to do; from the inside it is the kind of isolation that keeps the parent simple and the skill replaceable. Used here, the puppeteer pattern is what makes skills composable in the first place.

So the real question is not puppeteer or pulse. It is: which hat is right for which job?

Bounded, well-scoped tasks — a particular kind of search, a particular kind of refactor, a particular kind of negotiation — often deserve the CEO hat. The parent contributes intent; the subagent contributes skill. Both stay simple, and the parent never has to hold the steps in its head.

Organisational complexity — long-running jobs with their own goals, their own state, their own pace — almost always wants the chief of staff. It is conceptually beautiful to imagine an organisation pulling toward one shared goal; in practice, the goal is so abstract that holding it as a single plan is almost impossible to comprehend, and most things get done as a federation of jobs that each know what they are for. Try to micromanage that from one place and the coordination cost eats the system.

The default for a multi-agent system should be the pulse. The puppeteer should appear where it earns its place — when a task is bounded enough that telling someone what to do is cheaper than letting them figure it out. Use both. Just notice which hat you are wearing.

The cron-based heartbeat has done good work. OpenClaw is genuinely useful. Letta's chained heartbeat is genuinely elegant. But both treat the scheduler as infrastructure — something to configure, not something to think.

The agentic heartbeat is the recognition that the scheduler is the part of a multi-agent system most worth making intelligent, because it controls the only resource that matters: the attention of every other agent. Make that part reason. Keep its routine signal a pure pulse. Let agents keep their own clocks for what only they can know to time. Reach for the puppeteer's hat when a specific skill is best dispatched by intent — and not by default.

The agents we run today wake on a clock. The agents we run next will wake when another agent decides it is time — and the difference will not be in what they can do, but in when, and at whom, the beat is sent.