{
  "video": {
    "id": "32nrHU6zHU8",
    "title": "Agents Are Where Microservices Were in 2015 — Roberto Milev & Uday Kanagala, Navan",
    "duration": 1168,
    "upload_date": null,
    "channel": "AI Engineer",
    "source": "AI Engineer"
  },
  "analysis": {
    "video_id": "32nrHU6zHU8",
    "title": "Agents Are Where Microservices Were in 2015 — Roberto Milev & Uday Kanagala, Navan",
    "one_liner": "Navan's chief architect and an architect on his team argue that agentic systems in 2026 are where microservices were in 2015 — a reference architecture (runtime, memory, context, observability, evals, guardrails, orchestration) is crystallizing, and the rule is: if you can't build a single agentic loop, don't try to build a multi-agent orchestrated system.",
    "summary": "Roberto Milev (chief architect) and Uday Kanagala (architecture team) at Navan, a travel and expense management company, map the emerging agentic reference stack against the microservices era that gave us Kubernetes, service mesh and circuit breakers. They walk layer by layer through what they run in production on AWS — agent core runtime (with session persistence and rehydration built in-house to fill gaps), agent core memory, skills as the unit of context with progressive disclosure, hook-based tracing at pre/post tool call, trajectory evals for non-deterministic multi-step agents, and pre/post-tool-call guardrails plus fine-grained authorization. They close by scoring each layer's maturity: runtime is 'pretty much solved', MCP has emerged as the de facto tool protocol, while cost prediction, replay/debugging, OTEL fit for agentic calls, and standards like A2A remain open. Their architectural choice at Navan is a single master agent that progressively loads sub-skills, not a multi-agent orchestration.",
    "key_points": [
      "The framing quote from the microservices era — 'If you can't build a well-structured monolith, why even try to build microservices?' — translates directly: if you can't build a single agentic loop, don't build a multi-agent orchestrated system.",
      "A reference architecture is crystallizing across layers: runtime, memory, context management, observability/operational cross-cutting concerns, guardrails/authorization, and orchestration.",
      "Agents are stateful by nature — persistent sessions, isolation, a different lifecycle from a traditional API service — which breaks the stateless-scaling assumptions services were built on. AWS, GCP and Azure each ship some incarnation of an agentic runtime; Navan runs AWS agent core runtime and built session persistence and rehydration themselves to fill the gap.",
      "Memory started as RAG out of necessity (you can't fit unlimited context into an agent) and has become an automated pipeline of ingestion, extraction, consolidation and retrieval, building from short-term conversational memory to self-managed long-term memory to episodic memory about which instances worked well and which didn't. Navan uses AWS agent core memory.",
      "Navan treats skills as the unit of context: a skill carries both context (instructions and setup for a domain or task) and tool execution. Skills are pluggable, independently testable and reusable, composed dynamically, and rely on progressive disclosure to start with limited context and expand via metadata.",
      "Logs don't work for agents — agents output too much thinking to consume. Instead, intercept at Claude-style hooks (pre-tool/post-tool, pre-decision/post-decision) to block, log or emit a metric, and emit auto traces there. The signals they capture: the agent's current goal, the reasons behind its operations, its belief state, its tool calls, and a confidence score including whether an answer was inferred — inferred answers can route to a human in the loop.",
      "Because agents are non-deterministic and make up their own steps every time, you cannot chart a deterministic graph of a 30-step run. Navan relies heavily on trajectory evals: measure how far the agent got along the trajectory from source to goal to evaluate efficiency and completeness, and use the inferred-answer signal to classify regressions.",
      "Authorization is blurred — an agent may act on behalf of a user ('book me a flight whenever it's cheaper than $200') or use a service account, so you need fine-grained authorization and a policy layer. Navan runs guardrails on every pre-tool and post-tool call to check and block.",
      "Maturity scorecard: runtime is pretty much solved and scaling isn't a problem; memory has good cloud-provider maturity; MCP is the de facto tool protocol and is evolving toward stateless. Still open: whether OTEL really works for agentic calls, replay and debugging, A2A is young and vendor-pushed, and cost is very hard to predict and manage — with the pointed note that the big AI vendors' interest is for everyone to spend more tokens.",
      "For cross-team boundaries in a large organization where teams don't talk to each other, A2A is proposed as the protocol that establishes contracts in terms of skills."
    ],
    "takeaways": [
      "Perfect the single agentic loop before reaching for multi-agent orchestration — the explicit advice is 'probably the right answer is to not over-engineer'.",
      "Stop debugging agents through logs. Instrument at hook points (pre/post tool call, pre/post decision) and emit auto traces carrying goal, reasoning, belief state, tool calls and a confidence/inferred flag, so you can pinpoint where a 30-step run got stuck.",
      "Structure context as skills — instructions plus tool execution bundled as pluggable, independently testable, reusable units — and let progressive disclosure expand scope rather than loading everything up front.",
      "Replace deterministic test expectations with trajectory evals: score how far the agent traveled from start toward the goal, and use inferred-answer signals to detect regressions and trigger human-in-the-loop review.",
      "Put guardrails and fine-grained authorization on every tool call, and decide explicitly whether the agent is acting on behalf of a user or via a service account before sensitive data reaches the model.",
      "Treat cost as an unsolved architectural problem: plan fallbacks and route cheaper models to certain tasks rather than assuming vendor defaults are aligned with your spend."
    ],
    "topics": [
      "agents",
      "multi-agent",
      "agent-infrastructure",
      "observability",
      "evals",
      "memory",
      "context-engineering",
      "guardrails"
    ],
    "tools": [
      "Navan",
      "AWS",
      "AWS Bedrock AgentCore runtime",
      "AWS AgentCore memory",
      "GCP",
      "Azure",
      "Kubernetes",
      "Claude",
      "MCP (Model Context Protocol)",
      "A2A (agent-to-agent protocol)",
      "OpenTelemetry (OTEL)"
    ],
    "quotes": [
      {
        "text": "If you can't build a well-structured monolith, why even try to build microservices?",
        "at": "01:20",
        "url": "https://www.youtube.com/watch?v=32nrHU6zHU8&t=80s"
      },
      {
        "text": "if you can't build a single agentic loop, why go in and try to build a multi-agent orchestrated system?",
        "at": "01:28",
        "url": "https://www.youtube.com/watch?v=32nrHU6zHU8&t=88s"
      },
      {
        "text": "Agents output a lot of thinking. There's too much to consume. So, that's not the right way to do it, right? So, traditionally, that was the way, but our thought has to be changed right now.",
        "at": "07:19",
        "url": "https://www.youtube.com/watch?v=32nrHU6zHU8&t=439s"
      },
      {
        "text": "it's very hard to predict cost and it's very hard to manage cost... this is all driven by kind of the big AI vendors who, I think, their interest is for us all to spend more tokens.",
        "at": "17:55",
        "url": "https://www.youtube.com/watch?v=32nrHU6zHU8&t=1075s"
      }
    ],
    "words": 3315
  },
  "summary_url": "/#32nrHU6zHU8",
  "transcript": {
    "html": "/transcripts/32nrHU6zHU8.html",
    "txt": "/transcripts/32nrHU6zHU8.txt",
    "vtt": "/transcripts/32nrHU6zHU8.vtt"
  }
}