AI Engineer35 min
Every Company Is Building Agents That Can't Work Together - Justin Schroeder, Standard Agents
Conference Presentation, Keynote, Product Demonstration
Core Market Observation
- Current market trend shows businesses prioritizing the construction of specialized agents over the prevailing "MCP server + Markdown documentation" architecture recommended by AI experts.
- This deviation suggests the market possesses inherent wisdom regarding the limitations of generic, undifferentiated AI interactions in business-critical environments.
- Three primary drivers explain why organizations build custom agents rather than relying on generic "Grokbot" or "Claude" style agents: integration, trust, and efficacy.
Business Requirements for Custom Agents
- Integration: Businesses require AI to manage deeply embedded, non-generic processes (e.g., HVAC warranty claims, crew scheduling, permit pulling, university financial aid, cloud billing) that define organizational value.
- Trust and Liability: Organizations demand strict scope restriction for agents; a model capable of doing "anything" introduces unacceptable liability, whereas agents limited to specific tools (e.g., "lookup equipment," "attach photos") ensure predictable execution.
- Efficacy over Efficiency: The primary goal is ensuring a specific task is performed correctly (high eval pass rates) rather than just being cost-efficient or using a massive model.
- Benchmarking Advantages: Fine-tuning or prompting a narrow domain-specific agent allows for positive benchmarking and continuous improvement on specific tasks, unlike large general models which optimize for broad capabilities.
- Cost and Performance: Smaller, specialized agents (e.g., DeepSeek v4.1 Flash for a Gmail task) often outperform larger models (e.g., Opus 5.5) at a fraction of the cost for specific workflows.
The Problem: Lack of Standardization
- Current agent development is fragmented, with teams writing unique orchestration loops, tool formats, and state management systems in various languages.
- Custom "harnesses" lack interoperability, preventing the sharing of agents between organizations or the easy composition of different agent types.
- MCP (Model Context Protocol) alone is insufficient because it often necessitates rebuilding inference loops within the tool layer, effectively recreating an agent system without solving the runtime standard.
- Scaling to hundreds of custom agents is unsustainable without a unified specification for the agent runtime and lifecycle.
The Solution: Standard Agent Specification
- Definition: An agent is defined as "deterministic software that harnesses the non-deterministic results produced by models in pursuit of a desired objective."
- Core Principles: The spec enforces five principles: vendor agnosticism (runs anywhere), domain specificity, model coupling (pinning specific models for efficacy), composability, and portability (packagable as code).
- Runtime Standardization: The specification defines the agent runtime to ensure consistency, speed of development, and portability, allowing agents to be written once and run on any compliant runtime.
- Code-First Architecture: All agent definitions must be written as code to enable packing, distribution, and agent-to-agent creation, rather than relying on static markdown files.
- Language Choice (TypeScript): The spec mandates TypeScript because it runs everywhere (edge, server, client) and is interpreted, allowing agents to write and execute other agents immediately without compilation steps.
- Model Coupling: Agents can pin to specific models (e.g., Tencent Y3 for 3D generation) to leverage "jaggedness" (specific strengths) rather than generic model swapping, ensuring high efficacy for domain tasks.
- Conversation Modeling: The spec supports mixed conversation types: AI-to-Human, AI-to-AI (for internal QA/eval), and deterministic code-to-human, with handlers managing these flows.
- Hooks and Effects: Agents utilize deterministic hooks (events like
filter messages before tool call) and scheduled effects (e.g., alarms, future emails) to manage logic outside of model inference. - Thread Isolation: Every agent thread acts as a sandbox with its own file system, KV store, sub-agents, and isolated code execution environment, with configurable permissions (e.g., internet access).
- Packaging: Agents are designed to be bundled into NPM-like packages, enabling easy distribution, installation, and composition within larger systems.
Announcement: Standard Agent Builder
- Standard Agent Builder is the first public runtime implementation of the specification, currently in production use.
- The tool allows a coding agent to generate new agents in approximately 5 minutes and 21 seconds by automatically defining models, prompts, and tools according to the spec.
- The runtime provides an admin view tracking specific metrics: tool usage, token counts, costs, cash rates, and full request/response bodies for debugging.
- Generated agents expose both HTTP and WebSocket endpoints and can function as standalone chatbots or be exposed via MCP servers for integration with external interfaces like ChatGPT.
- The runtime is open source; the spec allows third parties to build alternative runtimes in any language capable of executing the TypeScript specification.
Future Outlook and Ecosystem Goals
- The goal is to foster an ecosystem of shareable, domain-specific agents similar to the early standardization of the web browser market.
- The specification is open to community iteration and breaking changes to push the ecosystem forward, similar to the evolution of JavaScript.
- The speaker invites developers to build compliant runtimes and publish agents to the ecosystem to accelerate the shift from generic AI to standardized, deterministic agentic software.