Designing Agent Fleets
Published by O'Reilly Media, Inc.
Build the control plane that runs many AI agents at once
What you’ll learn and how you can apply it
- Design an agent fleet as a systems architecture: Define the workload, run contract, worker contract, state boundaries, failure boundaries, and control-plane responsibilities
- Build around the run as the unit of work: Model each agent run as a durable, verifiable task with a workspace, artifacts, events, an exit condition, and a verifier
- Design the fleet control plane: Coordinate queues, worker capacity, leases, scheduling, durable state, verification, failure handling, and spend limits
Course description
If your product runs general-purpose agents in cloud sandboxes, or your team has adopted coding agents, you’re already operating a fleet of autonomous agents running concurrently in isolated environments, producing work someone has to trust. Managed agent runtimes, Kubernetes Agent Sandbox, and self-hosted operators show the same pattern emerging across cloud and open source systems. The hard part is the control plane that decides what runs, where it runs, whether the work holds up, and when to stop.
Join Sajal Sharma to explore that layer as a systems design discipline. The architecture follows from the agent worker: the run as a durable, verifiable unit of work; the contract between workers and the control plane; and the queue, scheduler, state, and acceptance loop required to coordinate a pool. Essential operational signals appear where they affect the design: queue depth, worker health, failed runs, verifier results, and spend. Concepts are folded into a systems design case study: define the workload, assign state and failure boundaries, assemble the reference architecture, and map it to open source and AWS components. In just two hours, you’ll design and size an agent fleet, and you’ll be equipped to explain its failure modes and evaluate platforms that provide pieces of a fleet.
This live event is for you because...
- You’re a platform or infrastructure engineer who’s designing the control plane, worker pool, queues, state stores, and runtime boundaries for agent workloads.
- You’re an AI product or backend engineer who’s moving from a single agent prototype to a service with worker pools, scheduling, verification, and cost controls.
- You’re a senior engineer, architect, or technical lead who’s evaluating build-versus-buy choices and mapping a vendor-neutral fleet architecture to open source, Kubernetes, or cloud platforms.
Prerequisites
- A Python environment—Python 3.12+ with pip/uv available to install packages
- An Anthropic API key
- A code editor (VS Code recommended) and terminal access
- Experience building or operating at least one AI agent with any framework
- Familiarity with running an agent in a sandbox
- Distributed systems background is helpful but not required
Recommended preparation:
- The prewired agent loop, tool stubs, and all demo code will be shared in a GitHub repo before the course
Recommended follow-up:
- Explore Building AI Agents with LangGraph (on-demand course)
- Read AI Agents: The Definitive Guide (book)
- Take Harness Engineering for AI Agents (live online course with Richmond Alake)
- Take Getting Started with Claude Agent SDK (live online course with Sajal Sharma)
Schedule
The time frames are only estimates and may vary according to how the class is progressing.
From agent run to worker contract (60 minutes)
- Presentation: Defining the run—objective, workspace, artifacts, events, exit condition, and verifier; turning it into a worker task—sandbox, assignment, scoped access, heartbeat, result reporting, and cleanup; establishing the worker contract—the API and state transitions between the control plane and a worker
- Hands-on exercise: Build a worker that claims one run, emits events, writes an artifact, and passes a verifier
- Q&A
- Break
The shell, the files, and routing (60 minutes)
- Presentation: Forming the worker pool—worker identity, capacity, health, leases, and heartbeats; queueing and scheduling runs—durable queue, model quota, priority, backpressure, and spend limits; recording and verifying outcomes—running state, artifacts, verifier results, and accept or retry decisions; mapping the architecture—connecting the local components to an AWS-focused deployment
- Hands-on exercises: Extend the worker into a small fleet, send it a batch of runs, and retry one failed run
- Q&A
Your Instructor
Sajal Sharma
Sajal Sharma is an AI engineer and technology leader with over eight years of experience in AI/ML, specializing in natural language processing. He works at Liminal, a venture studio in Singapore, where he focuses on building AI-first products and shaping technology strategies. Previously, he led AI initiatives at various consulting and product companies, developing innovative AI solutions across industries. His on-demand course, Building AI Agents with LangGraph, is available on the O’Reilly learning platform. Sajal has delivered a guest lecture at Yale University and has been a mentor for Udacity and the University of Melbourne, where he guided students in machine learning and AI. He holds a master’s degree in information technology from the University of Melbourne.
Skills covered
- AI Agents
- QA / Testing