Skip to Content
View all events

Designing Agent Fleets

Published by O'Reilly Media, Inc.

Intermediate content levelIntermediate

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:

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