AI Agents Are Where Microservices Were in 2015

AI agents are stateful, hard to observe and still expensive to run. In a talk published by AI Engineer, Navan chief architect Roberto Milev and architect Uday Kanagala argue the stack to run them is settling, just as microservices did around 2015.

Their message is blunt. If you cannot build a single agentic loop well, do not try to build a multi-agent system.

The runtime layer is finally productized

Milev frames agents as the opposite of the stateless services teams spent a decade scaling. Agents need persistent sessions, isolation and a different lifecycle.

Cloud providers have filled the gap with agentic runtimes. Amazon (NASDAQ:AMZN) has AgentCore Runtime, Alphabet (NASDAQ:GOOGL) and Microsoft (NASDAQ:MSFT) have their own versions, all claiming to be framework agnostic while nudging you toward their native framework.

Navan runs on AWS and uses AgentCore heavily. Milev said the team had to build session persistence and rehydration themselves and still runs multiple agent SDKs on top.

That last detail matters. Even with managed runtimes, most teams still glue together LangGraph, CrewAI or vendor SDKs and paper over gaps.

Memory moved beyond RAG, context is now skills

RAG was the first answer to limited context windows. The new pattern is an automated pipeline: ingestion, extraction, consolidation, retrieval.

Providers now bake this into long term memory with semantic search, plus short term conversational memory and episodic memory for what worked and what failed. Navan uses AgentCore Memory but tailors consolidation for travel and expense data where a past itinerary is more useful than a generic chat snippet.

Context windows keep growing and that creates a new failure mode. Too much context dulls focus and drives cost.

Milev's fix is to treat skills as the unit of context. A skill bundles instructions and the tools to execute a domain task. The runtime composes skills dynamically and uses progressive disclosure to load metadata first, then expand.

It makes context pluggable, testable and reusable. You do not paste the whole expense policy into every turn, you load the expense skill when the intent needs it.

Logs do not work for agents

Uday Kanagala asked who has debugged a 20 or 30 step agent run with logs alone. Logs drown you in thinking traces.

His replacement is intercepts at decision points. Using hooks similar to Anthropic's Claude hooks, Navan emits traces pre-tool and post-tool, pre-decision and post-decision. Each span captures current goal, reasoning, belief status, tool calls and a confidence score.

The score flags inferred answers versus grounded choices. That is where human in the loop belongs. Low confidence becomes a signal, not just text.

He was clear that OpenTelemetry helps but does not map cleanly to agentic calls. Spans, traces and metrics exist, but judgment and belief do not fit neatly into HTTP style telemetry.

Testing must become trajectory evaluation

Deterministic tests break when the same prompt can generate a different 30 step path each time.

Kanagala said Navan now evaluates trajectory completeness: how far did the agent get from start to goal and how efficient was the path. It is borrowed from research on multi step orchestration and replaces pass fail assertions.

This also forces a different regression model. When you tweak a prompt and something else breaks, you classify inferred answers and track whether the fix moved the trajectory forward.

Guardrails and orchestration: single agent first

Enterprise governance gets harder when an agent acts on behalf of a user. Booking a flight when the price drops below $200 sounds simple until you ask who actually authorized the purchase.

Navan enforces checks pre-tool and post-tool for sensitive data, policy and fine grained authorization. The agent is neither pure user nor pure service account, so the policy layer must decide per tool call.

On orchestration, Navan chose a single master agent with sub-skills that load progressively. Milev warned against jumping to multi-agent orchestration before the single loop is solid.

Agent to agent communication has its place. For large orgs with team boundaries, the A2A protocol provides a contract for skills to be exposed across agents. But it is a boundary tool, not a default.

Why this matters

The talk is a useful map of what is solved and what is not.

Runtime, memory and MCP based tool calling are converging. Scaling LLMs is brute force and works. Memory pipelines are standardized.

Observability, testing, cost predictability and replay debugging are not. Milev flagged cost as the most open problem, driven by vendor incentives to burn more tokens, with no reliable way to fallback to cheaper models per task.

That split explains why enterprise agent deployments feel stuck. You can ship a demo on a managed runtime in a week, then spend quarters making it debuggable and billable.

For founders, the opening is not another runtime. It is the missing cross cutting layer: traces that capture judgment, evals that measure trajectory, and controls that predict and cap cost per run.

Navan did not claim to have solved those. The point was that agents, like microservices in 2015, finally have a reference architecture. Now the hard work of making it boring and reliable starts.