Building Long-Horizon Agents

Many implementations of AI agents have a fundamental problem: they only work when prompted. These systems act like reactive utilities—they wait for input, process it through predefined steps, then go idle. This event-driven design creates a hard boundary that prevents sustained, autonomous operation.

Applications (like teaching) that require long-term engagement, planning, and management reveal how inadequate purely reactive agents are. Instead, we propose agents that exist independently from their user or input events.

This work presents a fundamental redesign of how agents operate. We introduce the long-horizon agent: an agent that schedules its own activities, reasons about time, and creates dynamic workflows on the fly. These systems maintain persistent awareness of context while adapting their behavior to align with changing objectives.

The standard reactive agent architecture follows a simple, deterministic pattern:

input event → LLM → workflows → output

This single-pass model breaks down when there's no external input. Without external input, the architecture has no way to take initiative. Below are iterative examples of how existing architectures attempt to fix this problem:

def on_button_pressed(...):
    foo = workflow_part_1(...)
    bar = workflow_part_2(foo)
    baz = workflow_part_3(bar)
    return baz

def run_every_hour(...): # runs 0 * * * *
    lessons = get_upcoming_lessons() # in next hour
    for lesson in lessons:
        lesson.plan() # another LLM call to plan the lesson

def run_every_hour(...) # runs 0 * * * *
    for user in db.get_users()
        context = user.gather_context()
        workflows = decide_workflows_with_llm(context)
        for workflow in workflows:
            workflow.run()

def run_agent(user):
    context = user.gather_context()
    done = False
    history = []
    while not done:
        tool_call = call_llm(context, history)
        done, resp = handle_tool_call(tool_call)
        history.extend([tool_call, resp])

def run_every_hour(...) # runs 0 * * * *
    for user in db.get_users():
        run_agent(user)

While this shows why dynamic workflows are required, the agent is still static across time.

To eliminate the fixed, inefficient beat schedule, the agent needs to be able to schedule itself. After completing a workflow, the agent decides when it should wake up next:

next_wake = LLM.decide_sleep_duration(context)

With this approach, a simple cron job can wake agents whose sleep time has expired—similar to how operating systems handle timer interrupts. This allows the agent to allocate compute resources dynamically over time.

But pure self-scheduling creates a problem: handling external events (like user messages) is delayed until the agent wakes up. To solve this, we added wake events—signals that immediately wake up sleeping agents when something important happens:

if event in WakeEvents:
    wake(agent)

This hybrid model combines agent-scheduled sleep, dynamic workflow creation, and event-based interrupts—achieving both autonomy and reactivity. The architecture creates individualized timing patterns for each user while scaling computation sublinearly.

def run_agent(user):
    # ... everything from before ...

def wake_agent(user):
    run_agent(user)
    user.agent_sleep_until = llm_decide_sleep_until(context)
    user.save_to_db()

def run_every_min(...) # runs * * * * *
    for user in db.get_users()
        if time.now() > user.agent_sleep_until:
            wake_agent(user)

Asynchronous events provide preemptive activation mechanisms:

def message_webhook(...): # called on external messages
    user = user_from_identifier(...)
    wake_agent(user)

Long-running agents require memory systems that evolve over time. Traditional agent systems use knowledge graphs, RAG, or context compression for memory. While these approaches can recall factually-related information and limited history, they fail to maintain truly temporal coherence across extended periods of time.

Instead, we present Decaying-Resolution Memory, a hierarchical system that summarizes interactions at different time scales. This approach achieves sublinear token scaling—memory grows much slower than interaction volume—while preserving temporal relationships.

When using decaying-resolution memory, information such as contacts, events, or long-term records should not be prioritized. Instead, these structures should live in stateful tools, mirroring the way humans offload knowledge to calendars, notebooks, or contact lists. By leveraging stateful tools as externalized memory, the agent preserves both temporal consistency and accumulated knowledge.

For example, an agent could run with a sandbox of persistent, stateful tools:

• Dedicated messaging inbox
• Calendar subsystem for scheduling and history
• Contact registry with rich metadata

Offloading memory in this fashion reduces the cognitive burden on the model itself and promotes robust, long-lived state. The main engineering challenge lies in synchronizing, isolating, and scaling these stateful components alongside agent runtimes.

{
  "name": "email_list_operation",
  "schema": {
    "type": "object",
    "properties": {
      "limit": {
        "type": "number",
        "description": "Limits emails returned."
      }
    }
  }
}

{
  "name": "check_email_inbox", 
  "schema": {
    "type": "object",
    "properties": {
      "limit": {
        "type": "number",
        "description": "Limits emails checked."
      }
    }
  }
}

Moving logic from deterministic software to learned behavior makes evaluation extremely complex. Standard LLM benchmarks like per-prompt accuracy, factuality, and latency don't capture temporal coherence, long-term decision making, or the agent's quality of initiative.

We have found that evaluations of long-horizon agents must be done through long-term simulation, not single-step evaluation. To do this, we define a set of qualitative metrics for our use case and continuously judge our agents against them.

Our experience is that exploratory reasoning-optimized models consistently outperform models that optimize for instruction following or latency.

• Concurrency: Ledger-style memory enforces single-threaded execution per agent. Parallel runs risk temporal inconsistencies.
• Latency and cost: Self-scheduling cuts idle compute, but wake bursts still cost. Budgets and backpressure are required.
• Event plumbing: Missed wake events degrade responsiveness; reliable queues and retries are mandatory.
• Memory trade-offs: Layered summaries can lose precise facts; store durable facts in tools (calendar/contacts/CRMs).
• Scope: Validated in our domain; broader generalization needs more evidence.

Building long-horizon AI agents requires rethinking how we architect autonomy. Instead of waiting for user prompts, these systems plan, remember, and act on their own timeline.

Long-horizon architectures are computationally expensive and operationally complex, but they create agents that care—systems that take responsibility for outcomes over time, not just individual interactions.

As reasoning models improve and inference costs fall, long-horizon agents will define the next generation of AI systems: continuously attentive, self-regulating, and aligned with their users' long-term interests.

We're preparing a minimal reference for the scheduler and wake queue. If you want to collaborate on long-horizon evaluations or try this in your domain, reach out.