Uday Kanagala is a software architect whose work spans cloud-native infrastructure and the operation of agents inside enterprise systems. A member of Navan’s architecture team at the time of his 2026 AI Engineer presentation with Roberto Milev, he examines how engineers can understand failed agent workflows, evaluate progress toward a goal, and control actions delegated by users.
From developer infrastructure to distributed systems
Before Navan, Kanagala worked at Anaplan on developer infrastructure, including CI/CD pipeline libraries, infrastructure automation, Kubernetes, and cloud-native tooling. His responsibilities expanded from platform engineering into leading tooling design and development, with attention to documentation and adoption by other engineers. His professional profile documents that progression into architecture work.
Kanagala also writes about distributed systems. His professional profile lists Consistency vs. Latency in Globally Distributed Databases, dated November 27, 2023. Its retained introductory excerpt describes databases that store and manage data across multiple geographic locations.
Building reliable agent infrastructure
Kanagala’s professional profile lists three ACM publications dated May 26, 2026, concerning agent-framework benchmarking, production issue resolution, and architectural governance across multiple repositories. In a post about Arena, he announced planned poster participation alongside Roberto Milev at ACM CAIS 2026. These profile-declared associations establish his engagement with those subjects without establishing exact publication or repository author lists.
In their joint presentation, Agents Are Where Microservices Were in 2015, Kanagala and Milev recommend making a single agentic loop reliable before adding orchestration complexity. Their account of production work at Navan connects persistent runtime sessions, memory, context management, tracing, evaluation, and authorization. They describe using AWS AgentCore runtime and memory, supplemented by session persistence and rehydration. Skills combine task instructions with tool execution and can be tested and reused independently. Progressive loading lets an agent begin with limited context and bring in further instructions as the task requires them. Their reported architecture uses a principal agent with sub-skills and some sub-agents, making additional coordination serve a specific need.
Tracing, evaluating, and authorizing agent actions
Agent observability begins with a concrete operational problem: an agent fails halfway through a twenty- or thirty-step task, and engineers must determine where it went wrong. In the joint presentation, Kanagala and Milev describe instrumenting tool calls and decision points rather than relying on large volumes of logs. Hooks before and after operations can emit traces and metrics or block an action. Traces that capture goals, tool choices, and signals about uncertainty help engineers locate a stalled step and identify where human review may help. These signals support investigation; they do not establish that an agent’s judgment is correct.
Trajectory evaluation: Their approach to trajectory evaluation addresses a related testing problem. An agent may choose different steps on successive attempts, making a fixed expected execution graph a poor fit for some tasks. Evaluating its trajectory means examining the path from the initial request toward the intended outcome: how far it progressed, whether it completed the work, and how efficiently it reached the goal. They connect this assessment to regression detection, acknowledging that a change improving one behavior can break another.
Fine-grained authorization governs what those trajectories may include. Their example of a user asking an agent to book a flight whenever the price falls below $200 illustrates the ambiguity of delegated action: the agent executes the purchase, but does so for a user. Permissions must account for whether it acts on that user’s behalf or through a service account. They describe checks around tool calls that can block operations, placing authorization within execution rather than leaving it as a general instruction to the model.
Profile-listed research on agent systems
Framework benchmarking: His profile lists Benchmarking AI Agent Frameworks Under Fixed-Model Conditions as an ACM publication dated May 26, 2026. His Arena post describes benchmarking frameworks with the model held fixed and announces planned poster participation alongside Milev. The retained evidence does not provide the paper’s author list, experimental setup, or results.
Production issue resolution: His profile also lists An Autonomous Agent Pipeline for Production Issue Resolution, dated May 26, 2026. The listing supports a publication association on that subject; the retained evidence does not establish its collaborators, implementation, or a corresponding Sherlock repository contribution.
Architectural governance: Autonomous Architectural Governance Through Commit Intelligence Across Multi-Repository Systems appears in the same Publications section with the same date. Its title identifies architectural governance and commit intelligence across repositories as its subject. The listing does not establish a corresponding Sentinel repository contribution or the system’s internal design.
Roberto Milev and Uday Kanagala explain Navan’s emerging production-agent stack: persistent sessions, layered memory, progressively loaded skills, tool-call controls, trajectory evaluation, and fine-grained authorization—plus the costs and debugging problems that remain open.
Establish a reliable single agentic loop before adding multi-agent orchestration; the speakers recommend avoiding that extra complexity until it solves a real need.
Production agents require persistent, isolated sessions and recovery through rehydration, even when a managed runtime supplies the basic execution environment.
For nondeterministic multistep agents, evaluate trajectory progress, efficiency, and completeness rather than requiring every successful run to follow an identical sequence.
Authorization must represent delegated action explicitly. A user’s earlier instruction does not by itself settle which identity and permissions govern a later purchase.
Runtime and tool invocation may be maturing, but predictable cost, replay, debugging, observability semantics, and agent-to-agent standards remain open work.