Businesses are building narrowly scoped agents because their important processes need control, repeatability, and reliable execution.
2
A standard agent runtime could make agents portable, composable, and easier to build without forcing every team to create its own harness.
3
The Standard Agent specification packages models, prompts, tools, subagents, hooks, effects, and threads as TypeScript code that can run in compatible runtimes.
Summary
Justin Schroeder argues that businesses keep building agents because generic models with broad tool access are too risky for business-critical processes. An HVAC warranty claim, for example, needs a controlled agent with specific tools and repeatable behavior. Small agents can also be evaluated for one task and paired with a model that performs well at that task. The problem is that teams build these agents with incompatible languages, tools, loops, and hosting assumptions. Schroeder presents the open Standard Agent specification as a common runtime contract. Agents are TypeScript packages containing models, prompts, tools, subagents, rules, hooks, effects, and thread state. The specification supports portability, model selection, agent-to-agent composition, scheduled effects, code execution, and explicit runtime behavior. He also demonstrates Standard Agent Builder creating a battery warranty agent from a PDF process in 5 minutes and 21 seconds. The proposal is new and explicitly open to competing runtimes and changes.
Businesses need agents that preserve their own processes
Schroeder says businesses are still building agents because their important work is embedded in processes such as warranty claims, crew scheduling, permits, financial aid, housing assignments, billing disputes, payroll, and contract review. These processes produce the relationships, data, and other value that make a business distinct. Handing them to a broad model with unrestricted access feels too risky. Businesses want control, reliable execution, repeatability, and a way to preserve their own tone and operating style.
A capable agent must be restricted to a defined job
Schroeder warns that an agent with broad capabilities may use them unexpectedly. A model handling a warranty claim could create an account, reply to unrelated emails, or inspect an X account simply because those tools are available. His proposed alternative is a full agent with multiple turns, context, evaluation, and the ability to perform real work, while exposing only the tools needed for one process. A warranty agent might look up equipment, attach photos, and submit a claim.
Small domain agents can outperform broad skills on their own tasks
The speaker separates efficacy from general model intelligence. A warranty claim can be treated as an agent rather than just a step in a workflow, then evaluated over time for that specific task. He says a Gmail agent can beat a Gmail skill because a smaller model can be tested and tuned for one operation. The same agent can then be exposed as an MCP server or placed under a larger agent in a hierarchy.
Teams cannot share agents when every harness is different
Agents are difficult to build because the visible ingredients, a model, prompt, tools, and message history, hide orchestration, parallel tool execution, asynchronous work, and recovery after errors. Teams also need inference inside tools, which can grow into another agent system. A custom harness built by one team may not run in another team's environment, and two custom agents may be fundamentally incompatible when someone tries to compose them.
A runtime standard adds speed, consistency, portability, and composition
Schroeder says existing standards cover surrounding pieces such as tools, skills, prompts, agent communication, and payments, but there is no standard for the agent harness itself. A runtime specification can define the loop and tool behavior once, while still allowing deep customization. It should let someone package an agent and give it to another person, publish it to a registry, or combine smaller agents into a larger system.
The Standard Agent specification treats agents as portable code packages
The specification defines agents as deterministic software that harnesses non-deterministic model results toward an objective. Its principles include vendor agnosticism, domain specificity, model coupling, composition, and portability. Agents are written in TypeScript so they can run across environments and be generated and executed without a compilation step. The package includes elements such as a model, system prompt, tools, subagents, rules, hooks, effects, and a thread.
Composition happens through tools, subagents, hooks, and conversations
The specification allows tools to be TypeScript functions, prompts used for a small inference task, or full agents. Two AI sides can work together, with one producing an asset and another reviewing it for errors. Subagents can be installed under a parent, and parent hooks expose or modify behavior automatically. Hooks run at defined lifecycle points, while effects schedule code such as reminders or emails for later execution.
Threads give each agent an explicit execution environment
Each thread has its own messages, tools, subagents, key-value store, and file system. An agent may write and run code when the runtime grants that permission, with explicit limits on imports and internet access. Threads can use decision models, expose HTTP or WebSocket endpoints, and package agents as npm packages. The specification defines the runtime contract without requiring one implementation, so a database-backed system can present a file system to the thread.
Standard Agent Builder shows how a process can become a working agent
Schroeder demonstrates Claude Code reading a battery warranty process from a PDF, then generating the agent's prompts, model, and tools. He says the process took 5 minutes and 21 seconds. The resulting agent uses explicit tools such as checking a battery, offering a trade-in, reporting a safety issue, escalating to a lead, and shipping a replacement. The builder exposes threads, tool calls, model details, token counts, costs, and the full request body.