Advertisements

Long-Running AI Agents: Patterns for Agents That Run Hours

Advertisements
35+ framework-agnostic patterns for context, memory, durable execution, guardrails and human approval
1
1/5
(21) Ratings
0 students
Created by BitSketch Academy
Advertisements

What you'll learn

  • Recognize the 5 ways long-running AI agents fail (forgetting, dying, getting stuck, lying, acting recklessly) and pick the right fix for each
  • Keep an agent’s context lean over hours of work with compaction, tool-result clearing, just-in-time retrieval and sub-agents
  • Give agents memory across sessions with progress files, structured work lists, action logs and the initializer-worker pattern
  • Make agents survive crashes and restarts with checkpoints, event logs, replay and idempotent tools
  • Decide when to hand-roll durable execution and when to adopt a workflow engine like Temporal, Inngest or Cloudflare Workflows
  • Run agents in the background on a schedule, pause them while waiting for webhooks, and process work queues safely in parallel
  • Stop runaway agents with retries, loop detection, token and money budgets, stop conditions and circuit breakers
  • Verify an agent’s work with deterministic checks, independent reviewer agents and periodic reconciliation instead of trusting its word
  • Put irreversible actions behind approval gates, handle async human approval, and defend unattended agents against prompt injection
  • Design orchestrator-worker systems, handoffs, tracing and cost controls for agents that run all night
This course includes:
3.5 total hours on-demand video
6 articles
6 downloadable resources
49 lessons
Full lifetime access
Access on mobile and TV
Certificate of completion
Advertisements

Course content

Requirements

  • You know what an AI agent is at a basic level: a model calling tools in a loop
  • You can read simple pseudocode (if, for, functions). No specific programming language is required
  • Having built or used an agent before helps, but is not required
  • No software, accounts or API keys needed: the course is diagrams and pseudocode, with nothing to install

Description

This course contains the use of artificial intelligence.

Building an AI agent that works for five minutes is easy. Building one that works for five hours, unattended, is a different problem.

Leave an agent running overnight and it breaks in predictable ways. Its context fills up and it starts mixing up customers. The server restarts at 2 AM and nobody knows whether that refund went through. It gets stuck in a loop and burns money until morning. It marks work as “done” when nothing was done. And sometimes it takes an action nobody can undo.

This course teaches the design patterns that prevent each of these failures. They are the same patterns behind today’s coding agents, background agents and durable workflow engines, explained clearly enough that you can apply them in any stack.

One story, one night, one agent

The whole course follows Nightshift, an agent working the night shift at Pebblecart, a small online store with 600 support tickets left over from Black Friday. Nightshift has real tools: it looks up orders, reads the refund policy, emails customers and issues refunds.

The first night goes badly. Section by section, you give Nightshift the patterns it needs, and in the last lesson it finishes a full night: tickets resolved, risky refunds waiting for approval, hard cases handed to humans, and a sensible bill.

The 5 ways long-running agents break, and what you’ll learn to fix them

  • Forgetting: compaction, clearing tool results, just-in-time retrieval, sub-agents, progress files, structured work lists, goal anchoring.

  • Dying: checkpoints, event logs and replay, idempotent tools, workflow engines, suspend and resume with webhooks, work queues with leases.

  • Getting stuck: retries with backoff, loop detection, token and money budgets, stop conditions, circuit breakers and fallback models.

  • Lying: verification with facts instead of the agent’s word, evaluator–optimizer reviewers, overnight reconciliation.

  • Acting recklessly: approval gates, async human approval, escalation, and defending against prompt injection in customer emails.

You’ll also learn when multiple agents beat one, how to hand off work between agents, how to trace an 8-hour run, and how to cut the cost of a night’s work.

What makes this course different

  • Patterns, not a framework. Everything applies whether you use the Claude Agent SDK, LangGraph, Cloudflare Agents, Temporal, Inngest or your own loop. Each lesson ends with where the pattern already exists in popular platforms.

  • Short, focused lessons. Every video is 3 to 6 minutes and teaches one pattern.

  • Animated diagrams instead of slides. Every idea is drawn and animated step by step, so you can see the mechanism, not just hear about it.

  • Pseudocode code cards. Each pattern ends with a short pseudocode card you can translate into any language. The harness grows lesson by lesson, with new lines highlighted.

  • No setup, no repo to maintain. Watch on your phone, on the train, or between meetings.

Also included

  • A scenario quiz at the end of every section, based on real incidents from Nightshift’s nights

  • A final assignment: design the harness for your own agent on one page

  • Pattern cards (PDF): one card per pattern with the problem, diagram, pseudocode and trade-offs

  • Pattern map (PDF): every pattern on one page, organized by failure mode

  • Overnight checklist (PDF): what to check before you let an agent run unattended

By the end of this course, you’ll be able to look at any agent, predict how it will fail on a long run, and choose the patterns that keep it on track.

Enroll now and give your agent a night shift it can survive.

This course is independent and is not affiliated with or endorsed by any of the companies or products mentioned. Pebblecart and Nightshift are fictional names created for this course.

Who this course is for:

  • Developers who have built an agent demo and now need it to run for hours without supervision
  • Tech leads and software architects designing agent systems for production
  • Product engineers adding background agents (support, operations, research, coding) to a real product
  • Engineers using an agent framework who want to understand what it does under the hood and what it’s missing
  • Not for you if you want a step-by-step coding tutorial for one specific framework: this course teaches patterns you can apply in any of them
Advertisements
713D17F9D465FC36C9CA
Advertisements
Advertisements
Free Online Courses with Certificates
Logo
Register New Account