# Bridging the Gap Between AI Builders and Domain Experts

## Executive summary

The future of AI agents favors highly specialized, domain-specific agents over monolithic 'god models.' The core argument is that by scoping agents to a narrow set of tasks (e.g., checking Gmail), they can achieve measurable, high efficacy. Achieving this requires solving the 'standards problem'—creating standardized metadata and runtimes that allow agents to be reliably shared, composed, and deployed, much like microservices.

## Key takeaways

- Domain-Specific Agents are the Future: Agents tuned for one small task can perform it exceptionally well, offering measurable efficacy. This contrasts with large models that attempt to handle too many disparate functions. This shift is viewed as a 'microservices mindset' for agent design.
- The Critical Need for Standards: The current lack of standards prevents the creation and sharing of effective agents. Solving this 'standards problem' is paramount for the ecosystem's growth.
- Prompt Engineering over Model Training: It is often more effective to train the prompt (the instructions and context) than to train the underlying model itself. The effectiveness of an agent is highly dependent on its 'harness' (tools and prompt structure).
- The Importance of Agent Run-time Standards: Just as JavaScript has multiple runtimes (e.g., Node, Deno, QuickJS), agents need standardized runtimes that guarantee consistent execution, regardless of the underlying model or provider.
- Microservices Paradigm for Agents: Building agents should adopt a microservices paradigm. Instead of relying on a big-brain router, discrete, small agents can be built to handle specific, recurring background jobs (e.g., checking issues every five minutes).

## Technical details

- Agent Architecture: The ideal architecture involves small, hyper-scoped agents that can compose tasks, similar to skills, but at the agent level. This is contrasted with complex 'big-brain' routers.
- Standards and Metadata: Standards should function as metadata pinned to an agent, ensuring that the agent carries all necessary components (prompt, model, tools, runtime specification) required for guaranteed efficacy.
- Agent Deployment: The process of building an agent should be abstracted, allowing a system to take a discrete task specification and programmatically generate a fully functional, deployable agent with precise tools and model specifications.
- Agent Composition: Agents can compose tasks, moving beyond simple tool calls. This composition can be structured as a tree or graph of sub-agents, though this is not the only viable mechanism.

## Practical implications

- Development teams should adopt a microservices approach when designing agent systems, focusing on discrete, single-purpose agents rather than monolithic AI routers.
- Prioritize solving the standards and runtime specification problem to ensure agent portability and guaranteed efficacy across different models and providers.
- The focus should shift from training massive models to engineering highly effective prompts and tool harnesses for specialized agents.
- Domain experts are critical for identifying high-value, narrow use cases that can drive the adoption of these specialized agents.

## Topics

AI Agents, MLOps, Microservices, Prompt Engineering, System Architecture, Standards Development, Standard Agents, AGNTCon + MCPCon North America

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