# Harness Engineering: Building the Production Cage for Powerful Domain Agents — Mike Chambers, AWS

## Executive summary

The presentation introduces 'Harness Engineering,' a critical concept for building production-grade AI agents at scale. Mike Chambers distinguishes between agents that are used (e.g., coding assistants) and agents that are built. For built agents, the harness encompasses all non-model components—such as memory, skills, tools, identity, and context management—that must scale independently. The core principle is that scaling these components separately, rather than deploying them in a single container, is essential for handling thousands of users and maintaining reliability.

## Key takeaways

- Two Types of Agents: Agents are categorized into 'agents we use' (productivity tools, coding assistants) and 'agents we build' (production-scale systems). The approach for built agents requires careful architectural planning.
- Defining the Harness: A harness is defined by subtraction: take an agent and remove the model component; everything left over is the harness. This includes the infrastructure, skills, and tools.
- Scaling Built Agents: For production agents, the harness must manage complex concerns like loop management, scaling, payments, identity, runtime, context management, and observability. Attempting to containerize everything together is incorrect for high scale.
- Avoiding 'Slop Ops': Build engineers must avoid 'slop ops' (clicking around a console to deploy resources). Instead, agents must build infrastructure using Infrastructure as Code (IaC) to maintain ownership and control over cloud deployments.

## Technical details

- Agent Architecture and Scaling: To achieve scalability for thousands of users, components like memory and loop management must be deployed as separate, managed infrastructures, allowing them to scale independently from the core agent logic.
- AWS Agent Core Deployment: The process utilizes the `agentcore` command line tool to deploy agents. This tool facilitates the deployment of multiple components (e.g., memory, agent runtime) as separate, scalable cloud infrastructure, enabling multi-tenant isolation.
- Memory Management: The system can be configured to deploy both long-term and short-term memory as managed cloud infrastructure, ensuring state persistence and retrieval across asynchronous agent invocations.
- Minimalist Agent Definition: A highly simplified agent can be deployed using only a JSON configuration file specifying a model and a system prompt, demonstrating that much of the agentic functionality can be managed by the core infrastructure.

## Practical implications

- Adopt a modular, component-based approach to agent development, treating memory, tools, and runtime as independently scalable services.
- Prioritize Infrastructure as Code (IaC) for agent deployment to maintain control and repeatability, avoiding manual console operations ('slop ops').
- Utilize specialized frameworks like AWS Bedrock Agent Core to manage the complex orchestration and scaling of multiple agent components.
- Design agents with clear separation of concerns, ensuring that the model, the business logic, and the state management (memory) are distinct deployment units.

## Topics

Harness Engineering, Generative AI Agents, AWS Bedrock, Agent Orchestration, Infrastructure as Code, Scalability, Context Management, AWS Agent Toolkit, Amazon Bedrock Agent Core, Strands agents SDK

Source: https://www.youtube.com/watch?v=gxVZ_1tuuq4