newsfilter
← Interviews
AI Engineer35 min

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

Justin Schroeder

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.