Abstract

The microservices revolution gave us a hard-won set of principles: small services with well-defined contracts, owned by independent teams, composable into larger systems, replaceable without rewriting the world. The agentic AI era is rediscovering these lessons the hard way. Most enterprises today are building agents the way we built monoliths fifteen years ago: each agent a self-contained stack with its own conversation store, its own auth, its own observability, unable to talk to the agent built down the hall.

There is a better pattern. We call it a MicroAgent, and it is to the agentic world what a microservice is to the API world. A MicroAgent is a lightweight, independently-deployable package consisting of two things: an MCP server that exposes domain-specific tools, and a prompt template that encodes domain expertise. That is the entire contract. No session management. No streaming code. No auth boilerplate.

Talk Outline (detailed)

Part 1: From Microservices to MicroAgents

- The principles we earned the hard way: bounded contexts, contract-first design, independent deployability
- Team ownership boundaries and Conway's Law in service architecture
- Why API gateways, service meshes, and shared platforms emerged
-The agentic monolith problem: three agents, three stacks, zero composability
- Why the first agent hides the cost and the third one exposes it

Part 2: The MicroAgent and Its API Contract

- The unit of value: MCP server + prompt template
- What a MicroAgent does NOT contain: sessions, streaming, auth, memory, tracing
- Ownership boundaries: one team, one MicroAgent, independent deployment
- MCP as the API contract: tool routing, prompt discovery via HTTP, If-Modified-Since caching
- State propagation: the _meta field as a state-update channel between MicroAgent and platform
- Backward compatibility rules for prompt templates and tool schemas

Part 3: The Shared Substrate

- Session events vs. message lists: designing for resumability and branching
- Context compression and tool output sampling as platform concerns
- Memory as a shared organizational asset across all MicroAgents
- Scopes, knowledge types, and on-demand generation via generate_memories
- File and artifact storage with reference passing
- Tracing and observability as platform defaults

Part 4: Composition and Engineering Economics

- Super-agents as orchestrators of MicroAgents
- Sub-agent delegation via as_sub_agent: true
- Conversation handoff and session transfer
- Framework landscape: Google ADK, OpenAI Agent SDK, AWS Bedrock AgentCore, LangGraph
- Runtime tradeoffs: self-managed Kubernetes vs. Lambda vs. Vertex Agent Engine
- The marginal cost of the next MicroAgent, and principles to take back to your own org