# Sandboxing, Agent Harnesses, and Agent Teamwork

## Executive summary

The discussion explores the evolution of AI agents from simple task execution to sophisticated SRE (Site Reliability Engineering) capabilities. The core argument is that true value lies not in faster triage (Mean Time To Resolve - MTTR), but in building an agent that learns and compounds operational memory across an organization's entire stack. Key architectural shifts include moving beyond rigid, deterministic tools toward non-deterministic problem solving, requiring advanced techniques like sandboxing, environment simulation, and establishing governance structures for multi-agent teams.

## Key takeaways

- The Value Shift: Learning over Triage: AI agents' primary value is shifting from simply reducing MTTR to building an agent that learns from every investigation. The goal is creating a compounding operational memory, allowing the system to improve its decision-making process and predict failure modes rather than just reacting to alerts.
- Harnesses Define Agent Capability: The 'harness' is defined as everything between the user and the LLM—including prompts, skills, file systems, and tools. The challenge is balancing necessary guardrails (to prevent agents from doing wrong things) with enough freedom to allow for complex, non-deterministic problem solving.
- The Need for Cross-Environment Testing: Because every company's infrastructure (e.g., Gojek vs. Uber) is unique, agents cannot simply be trained on general knowledge. Durable development requires simulating and testing agent performance across diverse, idiosyncratic production environments.
- Future State: Agent Teams and Governance: The next frontier involves multi-agent systems (e.g., a Coding Agent working with an SRE Agent). These teams require defined governance structures, similar to a RACI matrix, ensuring agents know their roles and how to share context without losing isolation.

## Technical details

- Agent Architecture & Harnesses: The 'harness' encompasses all components exposed to the agent, including prompts and skills. Tools like Claude CodeX are cited as high-level abstractions that facilitate complex interactions.
- Sandboxing and Security: As agents gain capability (e.g., moving from rigid custom tools to running Python/Bash), sandboxing becomes critical. The goal is achieving 'as much non-determinism inside the box, but with a really strong box' to prevent malicious or incorrect actions.
- Operational Memory & Context Graphs: The most valuable data is not raw logs, but structured knowledge of past decisions and failure modes. Techniques like 'context graphs' are needed to preserve and query the decision-making process (SOPs) in a human-readable format.
- Agent Teams & Workflow: The concept of specialized, interacting agents is emerging. The SRE agent and the Coding Agent must work together, sharing resources while maintaining proper isolation (e.g., using a 'planning' mechanism).

## Practical implications

- Focus on building robust 'harnesses' and guardrails around agents rather than solely optimizing the LLM itself.
- Design systems to capture decision-making processes (SOPs) from incidents, creating a structured operational memory that can be fed back into agent training/context.
- When developing AI tools for production, prioritize simulating performance across diverse environments to ensure portability and reliability.
- Architect multi-agent workflows with clear governance rules (like a RACI matrix) to manage interactions between specialized agents (e.g., SRE vs. Coding).

## Topics

AI Agents, SRE Automation, DevOps Platforms, LLM Orchestration, Build Engineering, Cleric, LangChain (Viv)

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