You Think the Agent Is Thinking Proactively—It's Actually Waiting for the Alarm Clock to Ring

Recently, a bunch of so-called proactive agents have popped up. They send you messages on their own, and while you're asleep they organize the day's conversations, euphemistically called dreaming. The names keep changing—Muse, Instinct, Dots, Claude Duet, Hone—and the setup looks like the next generation of interaction.

LangChain engineer nathan drezner lays out the trick in an article. His point, roughly: almost every proactive agent you've seen is essentially a cron job plus a prompt. The so-called memory mechanism that dreams at night is a background task that runs once a day; the so-called agent proactively reaching out to you is a scheduled task that triggers once an hour.

What is cron? The oldest scheduled-task tool in Unix systems; it entered the system in 1975. More than fifty years later, the core of the trendiest agent products is still sitting on this old thing.

To be clear, this isn't meant as a put-down. It's actually pretty interesting. He borrows the Baader-Meinhof phenomenon as an analogy, i.e., frequency illusion: as soon as you learn a new word, you feel like the whole world is saying it. It's the same in software engineering: once you understand a simple but effective design pattern, you start seeing it everywhere. cron is a pattern that keeps getting rediscovered.

He gives a set of numbers: for Managed Deep Agent running on LangSmith, more than 70% of runs come from scheduled execution, not messages typed in by humans. That ratio makes you pause for a second—humans look more like bystanders in this system.

One cron setup can support five kinds of behavior

• Memory: compress old conversations into more compact long-term memory, commonly called dreaming. In implementation, it's a compression task that runs once a day.
• Proactivity: wake up once an hour, let the agent take one step toward its goal, and turn the action into a proactive message pushed to the user.
• Smart triage: scan the Slack or email feed every ten minutes and pick out what's worth reminding.
• Follow-up: when a user says "remind me in three days," what gets scheduled is a future wake-up task.
• Orchestration: when an orchestration agent is waiting for an asynchronous subtask, it goes to sleep first and wakes itself up on time to check progress.

Five capabilities that sound completely different all trigger prompts on a schedule.

Building this kind of agent comes down to two things

nathan says there are two core components. One is a reliable cron server: developers can add tasks freely, with prompts and permissions, and when tasks are too dense at the same moment, it needs some jitter to spread the load. The other is a scheduling interface that the agent can use itself, so it can read, create, and modify reminders, but not do whatever it wants.

LangChain's Managed Deep Agents run on LangSmith Deployments, which makes this built in. Static scheduling is just a file:

# schedules/daily_digest.py
from managed_deepagents import define_schedule

schedule = define_schedule(
    cron="0 8 * * 1-5",
    timezone="America/Los_Angeles",
    prompt="Inspect the sales report using your tools and send a KPI readout.",
)

Dynamic scheduling is more fun. Wrap the Schedules SDK as a tool, and when a user casually says "send me a sales briefing every Monday," the agent creates a scheduled task by itself:

from langchain.tools import tool
from managed_deepagents import ManagedDeepAgentRuntime

@tool
async def set_schedule(prompt: str, cron: str, runtime: ManagedDeepAgentRuntime) -> str:
    """Run a prompt for the current user on a cron schedule."""
    item = await runtime.schedules.create(owner={"type": "user"}, cron=cron, prompt=prompt)
    return f"Created schedule {item['id']}."

There are also scenarios that work with a single sentence. For example, check_in_later takes a number of minutes and runs a prompt at the specified time for a one-off reminder.

Proactivity has been redefined

In traditional software, proactive means event-driven, triggers, and a complex scheduling logic. Now the least troublesome approach is the opposite: don't wait for events; just run once on schedule and let the model decide what to say. It's a dumb approach, but it works.

The price is trading compute for determinism. One cron plus one prompt has a cost sitting right there; whether it runs correctly depends entirely on the prompt and context. Behind that 70% figure is a large amount of tokens burned on schedule.

And precisely because the barrier is as low as one file plus one line of cron, this wave of proactive agents has spread so fast. A timer invented fifty years ago, plus a language model, has become this year's new product form.

Original article: https://x.com/i/article/2115474237418778624