# Every Company Is Building Agents That Can't Work Together - Justin Schroeder, Standard Agents

## Executive summary

The current landscape of AI agents suffers from fragmentation, where every company builds proprietary, non-interoperable systems. Justin Schroeder argues that for agents to reach their potential, they require portability and composition. He introduces the Standard Agents specification, an open-source standard defining a universal agent runtime. This spec mandates that agents are deterministic software harnesses, written in TypeScript, ensuring they can be packaged, distributed, and composed regardless of the underlying hosting environment or model provider.

## Key takeaways

- The Problem of Fragmentation: Currently, agents are built using diverse, proprietary methods (e.g., custom harnesses, various languages, different tool definitions), making them fundamentally incompatible and preventing large-scale, interoperable deployment.
- The Need for Standards: Businesses require agents that are not only highly effective (efficacy) but also reliable, controllable, and repeatable, making a standardized, portable runtime essential for enterprise adoption.
- Standard Agents Specification: The standard defines agents as deterministic software harnesses that must be vendor-agnostic, domain-specific, composable, and portable. It provides a unified structure for defining agents, including model, system prompt, tools, sub-agents, hooks, and effects.

## Technical details

- Agent Architecture and Components: An agent is defined by a package containing: a model, system prompt, tools, sub-agents, agent rules, hooks, effects, and a thread. The entire specification is designed to be written as code, enabling packaging and distribution (e.g., via a package registry).
- Implementation Language and Portability: The specification mandates using TypeScript because it is an interpreted language that runs 'everywhere' (edge, browser, etc.), allowing agents to be executed immediately without a build or compilation step. This ensures maximum portability.
- Agentic Workflow Control: The spec supports advanced control mechanisms: 'Hooks' (deterministic events like pre/post tool calls), 'Effects' (scheduled code, e.g., setting a future reminder), and 'Handlers' (deterministic code running on one side of the conversation).
- Thread Execution Environment: Each agent runs within a dedicated 'thread' (sandbox) that maintains its own state, including messages, tools, sub-agents, a KV store, and a file system. This isolation is critical for reliable, multi-step operations.

## Practical implications

- Build Engineers can use the Standard Agent Specification to design and implement custom, portable agent runtimes (e.g., in Rust or Go) that comply with the spec, rather than building proprietary harnesses.
- The ability to compose agents (e.g., running a 'Gmail agent' as a tool within a larger 'Warranty agent') allows for the creation of complex, multi-domain systems from standardized components.
- The specification's focus on deterministic code execution (via hooks and handlers) provides explicit control over the agent's behavior, mitigating the risks associated with purely LLM-driven actions.

## Topics

Agent Architecture, AI Runtime, Software Standards, TypeScript, Composition, System Design, Justin Schroeder, Standard Agents, Standard Agents Website, Standard Agent Specification

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