Skip to Content
View all events

Agent-Oriented Architecture

Published by O'Reilly Media, Inc.

Intermediate content levelIntermediate

Design agentic systems built from stable, specialized components

What you’ll learn and how you can apply it

  • Explain the core principles of agent-oriented architecture (AOA) and how it differs from agent frameworks and orchestration tools
  • Identify and define agentic units (AUs) with clear boundaries, contracts, and responsibilities
  • Design capability metadata that supports discovery, selection, evaluation, and governance of agentic units
  • Decompose existing workflows into composable agentic systems rather than monolithic agents
  • Compose and evolve a simple agentic pipeline using a local reference implementation

Course description

Agentic systems are rapidly moving from experimentation into production, yet many organizations struggle to apply them in a way that is scalable, governable, and resilient in the face of constant change in models and tooling. Lewis Crawford introduces agent-oriented architecture as an architectural approach for designing agentic systems built from stable, specialized components rather than monolithic agents or framework-specific solutions. The focus is on architectural principles that remain valid despite rapid advances in models and tooling, equipping you to design agentic systems that can adapt rather than be rewritten.

You’ll learn how AOA reframes agents as agentic units—independently deployable capabilities with explicit contracts, metadata, and lifecycles—and how these units can be composed, discovered, evaluated, and evolved over time. You’ll explore how to decompose real workflows into agentic units, define capability metadata, and compose working pipelines using a reference implementation that runs on local hardware.

This live event is for you because...

  • You’re a software architect, technical lead, or senior engineer who’s responsible for designing or governing AI-enabled systems.
  • You’re experimenting with agents and want a durable architectural foundation.
  • You’re evaluating how agentic approaches fit into enterprise systems, platforms, or internal developer ecosystems.

Prerequisites

  • Docker Desktop (or equivalent) installed on your computer
  • An understanding of software architecture

Schedule

The time frames are only estimates and may vary according to how the class is progressing.

See the shape: The agentic inversion (60 minutes)

  • Presentation: Why today’s agent approaches become hard to govern at scale; local AI acceleration versus system throughput; agent sprawl, hidden coupling, and framework lock-in; AOA as a way to make agent systems describable, discoverable, observable, replaceable, and governable
  • Demonstration: A small discovered multi-agent workflow showing intent, capability discovery, planning, tool use, trace, evaluation, and human judgement boundaries
  • Hands-on exercise: Review the workflow and identify the visible AOA control surfaces (AU, capability card, registry, planner, tool boundary, trace, evaluation signal, and human oversight point)
  • Q&A
  • Break

Name the shape: Anatomy of an agentic unit (60 minutes)

  • Presentation: Agentic units, capability cards, skills, working identity, tools, A2A boundaries, MCP-backed tool access, registry metadata, ownership, observability, evaluation signals, and lifecycle state
  • Demonstration: Guided inspection of a three-AU course system—parser, evaluator, and reporter
  • Hands-on exercise: Run or inspect the local reference environment, follow the trace, inspect capability metadata, and make one controlled change to the behavior behind a stable capability
  • Q&A
  • Break

Recognize the shape: AOA in the real world (60 minutes)

  • Presentation: How the same responsibilities recur across SOA, microservices, registries, agent frameworks, orchestration tools, A2A, MCP, vendor platforms, and sovereignty concerns; why frameworks can live inside AUs without defining the architecture
  • Hands-on exercise: Take a multi-agent or platform-oriented system description and map it against AOA control surfaces—contract, discovery, coordination, observation, evaluation, replacement, and governance
  • Q&A
  • Break

Apply the shape: Knowledge management and adoption (60 minutes)

  • Presentation: From a simple pipeline to a richer AOA knowledge-management system; ingest versus access workflows; promotion as judgement; graph inspection; grounded answering; trace as the bridge from demo behavior to governance
  • Demonstration: Building and inspecting a small knowledge-management system about AOA, using AOA patterns—ingest, promote, graph, ask, trace
  • Hands-on exercise: Build and inspect a small knowledge-management system about AOA, using AOA patterns—ingest, promote, graph, ask, trace
  • Q&A

Your Instructor

Skill covered

Enterprise Architecture