70% of Agent Runs Come From Scheduled Tasks—Humans Only Occasionally Speak Up

If you've used one of those AI assistants that proactively messages you—reminding you to reply to an email, following up on a topic, pushing a morning summary—then look under the hood, and chances are you'll find a cron expression.

Nathan Drezner wrote up an observation in the LangChain blog (original): almost every proactive agent you've seen is essentially a scheduled task plus a prompt. The so-called "memory dreaming at night" is the same mechanism: a cron that runs once a day and compresses prior conversations into denser long-term memory.

One reply said, so it's not just me. He mentioned the Baader-Meinhof phenomenon—once you learn a word, you suddenly see it everywhere—and it fits well here.

That sounds like it's taking the shine off. But it explains why these products are suddenly proliferating: Muse, Instinct, Dots, Claude Duet, and Hone all rest on the same operating-system concept from more than fifty years ago.

What cron unlocks

The author breaks the capabilities into several parts:

Memory consolidation. Background tasks compress conversation history at a set frequency and update long-term memory, commonly known as dreaming.

Proactivity. Cron wakes the agent every hour, lets it explore its next action around a goal, and pushes the result to the user. Specialized agents like Hone have clear goals; a general-purpose agent's goal may simply be to be a good assistant—say, reminding you of deadlines or following up on unresolved topics.

Smart triage. Monitor information streams such as Slack and email, run every ten minutes, and pick out messages worth surfacing.

Follow-up reminders. When a user asks the agent to remind them later, it's essentially scheduling a timed task.

Orchestration. An orchestration agent manages a group of agents; while waiting for asynchronous subtasks, it goes to sleep and wakes up later to check progress.

One data point: on LangSmith, more than 70% of Managed Deepagent runs come from scheduling, not from a human typing a message.

Two pieces are needed

First, a usable cron server. Developers can add tasks at any frequency, with the prompt to execute and the required skills and permissions. When too many tasks land at the same moment, the server should jitter them to spread out the load.

Second, an agent-friendly interface. For actions like follow-up reminders, the agent needs to be able to create and modify reminders itself, but under guardrails.

How MDA does it

Managed Deep Agents are hosted on LangSmith Deployments and come with a cron server. A scheduled run is quite plain: a prompt, triggered by time, with the thread and memory owned by the creator.

A static schedule 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 wraps the Schedules SDK as tools, letting end users create tasks at runtime:

# tools/scheduling.py
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']}."

@tool
async def list_schedules(runtime: ManagedDeepAgentRuntime) -> str:
    """List the current user's schedules."""
    page = await runtime.schedules.list(owner={"type": "user"})
    return str(page["items"])

@tool
async def delete_schedule(schedule_id: str, runtime: ManagedDeepAgentRuntime) -> str:
    """Delete one of the current user's schedules."""
    await runtime.schedules.delete(schedule_id, owner={"type": "user"})
    return f"Deleted schedule {schedule_id}."

Sometimes a simple "remind me later" is enough:

from datetime import datetime, timedelta, timezone

from langchain.tools import tool
from managed_deepagents import ManagedDeepAgentRuntime

@tool
async def check_in_later(prompt: str, minutes: int, runtime: ManagedDeepAgentRuntime) -> str:
    """Run a prompt once for the current user, a number of minutes from now."""
    at = datetime.now(timezone.utc) + timedelta(minutes=minutes)
    item = await runtime.schedules.create(owner={"type": "user"}, at=at, prompt=prompt)
    return f"Scheduled a check-in {item['id']}."

Docs are at langch.in/mda.

Truths from the comments

People added a couple of points. One commenter said the boring problems come with it: overlapping runs, tasks quietly stopping, and no one noticing for a week. Another mentioned the ramp-up phase: you have to watch the agent the whole time and feed it your way of doing things before it can really do the work.

Those two points are worth reading more than most demos. Cron isn't new; what's new is that this time, the thing it drives can talk.