AI Engineer · Published 2026-10-08

We Mapped 115 Microservices for Our Coding Agents — Kamalakannan Nandagopal, Postman

privateReview: unreviewedConfidence: high
API Context GraphCoding agentsmicroservicestelemetryimpact assessmentapi-context-graphcoding-agentsagent-memoryMCPground-truthtoken-efficiencyimpact-assessment
Open on YouTube ↗

Summary

Overview

  • Speaker: Kamalakannan Nandagopal
  • Channel: AI Engineer
  • Main topic: Beyond Code Generation: API Context for Agentic Engineering
  • Purpose: Explain how API Context Graphs solve the limitations of coding agents in complex distributed microservice architectures and present evaluation results comparing generic coding agents against API-context-aware agents. Kamalakannan Nandagopal, Staff Engineer at Postman, discusses how taking coding agents beyond code generation requires providing comprehensive API context. Postman mapped its 115+ microservices and 4,000+ endpoints into an API Context Graph grounded in hard truth (code and production telemetry). Evaluating coding agents (like Claude and Postman's AI agent) on tasks such as API discovery, API design/redesign, and impact assessment demonstrates that providing an API Context Graph dramatically improves agent evaluation scores while reducing token overhead.

Topic Map

Introduction and Context

  • Explanation: Kamalakannan introduces Postman's ecosystem (115+ microservices, thousands of REST API endpoints) and the evolution of coding agent adoption.
  • Key claims:
    • Coding agents excel in greenfield projects and single-project fixes but struggle with complex distributed production systems.
    • APIs are the context layer for distributed systems.
  • Examples:
    • Postman's migration from desktop-only app to extensive cloud microservices.
  • Terminology:
    • Coding agents
    • Microservices
    • API context
    • Agentic engineering
  • Why it matters: Sets the stage for why standard LLMs and coding assistants fail in large-scale production architectures without broader system context.

Improving Coding Agent Performance and Limitations of Documentation

  • Explanation: Discusses traditional approaches like documentation, skills, MCP, and agent memory, highlighting why purely LLM-maintained documentation degrades over time.
  • Key claims:
    • Developers hate writing and maintaining documentation, leading to overhead and outdated docs.
    • Skills and MCPs are only as good as the context they are provided to.
    • Agent memory is limited to individual users and lacks standard sharing across teams.
  • Examples:
    • Comparing engineering coding agent challenges with business go-to-market agents that use RAG and Graph RAG over customer data.
  • Terminology:
    • MCP
    • Agent memory
    • Retrieval-Augmented Generation (RAG)
    • Graph RAG
  • Why it matters: Identifies the core gap in current agent tooling: lack of centralized, up-to-date system context.

Building the API Context Graph

  • Explanation: Details the six-step process Postman used to build its API Context Graph, ensuring every data point is grounded in code or production telemetry.
  • Key claims:
    • Every data point in the context graph must be grounded in hard truth (code or production telemetry).
    • Cataloging services, mapping endpoint implementations, call relationships, data storage (caches/databases), and frontend/CLI consumption builds a comprehensive graph.
  • Examples:
    • Visual snapshot showing central cluster of core Tier 0/1 services surrounded by heavily bloated outer services.
  • Terminology:
    • API Context Graph
    • Production telemetry
    • Tier 0 services
    • Dependency cycles
  • Why it matters: Provides a reproducible blueprint for organizations to structure their architecture for AI consumption.

Evaluating the API Context Graph: API Discovery, Redesign, and Impact Assessment

  • Explanation: Presents evaluation results from real Postman GitHub PRs, comparing Postman's AI agent, Claude with code search, and Claude with the API Context Graph skill.
  • Key claims:
    • Over 75% of PRs on top repos affect APIs or integrate APIs.
    • API context graph significantly improves agent scores across API discovery, API design/redesign, and impact assessment while saving tokens.
  • Examples:
    • Finding the right API to get user profile name.
    • Analyzing input shapes when adding a dependency to an API task.
    • Assessing impact of changes to an endpoint and identifying downstream services.
  • Terminology:
    • API discovery
    • Impact assessment
    • Ground truth
    • Token efficiency
  • Why it matters: Proves empirically that API context graphs enhance agent accuracy, efficiency, and developer trust.

Key Points

Production systems are complex and distributed

  • Explanation: Enterprise applications consist of multiple microservices across multiple environments, multiple application frontends, and hundreds of code repositories.
  • Evidence: Postman's internal architecture spans over 115 microservices and 4,200+ REST API endpoints.
  • Practical implication: Coding agents operating only within a single repository lack the global view required for reliable multi-service changes.

APIs serve as the natural context layer

  • Explanation: In microservice architectures, domains and models define system boundaries, and API calls define workflows and user journeys.
  • Evidence: Complex architectures are broken down by domain and model, with each microservice owning specific responsibilities defined by its APIs.
  • Practical implication: Mapping APIs provides the necessary context layer for coding agents to reason about system-wide interactions.

Grounding context in hard truth prevents hallucination

  • Explanation: Every data point in the API Context Graph must tie directly to code implementation or production telemetry.
  • Evidence: Pure LLM-maintained documentation degrades exponentially over time without human curation.
  • Practical implication: Ensures agents do not rely on stale or hallucinated documentation.

75% of pull requests involve APIs

  • Explanation: The vast majority of engineering changes either modify API surface areas or integrate new APIs.
  • Evidence: Retrospective analysis of PRs across Postman's top 10 repositories.
  • Practical implication: API context is critical for the vast majority of real-world coding tasks.

Frameworks, Models & Processes

API Context Graph Construction

  • How it works: Catalogs production microservices and endpoints, maps call graphs, data dependencies, and client consumption to build an LLM-indexed graph grounded in code and telemetry.
  • Components:
    • Microservice cataloging
    • Endpoint implementation mapping
    • Inter-service call mapping
    • Data persistence tracking (caches/databases)
    • Frontend and CLI interaction tracking
    • LLM indexing with hard-truth grounding
  • When to use: When scaling coding agents across distributed microservice architectures.

Examples & Case Studies

A developer added a new property to a task API input schema, but two weeks later, 15 downstream services were affected because input shapes weren't clear.

  • Illustrates: The difficulty of API design and redesign without comprehensive consumer context.
  • Lesson: Analyzing all shapes of input and consumer usage via an API Context Graph prevents integration failures and loss of developer trust.

An evaluation of impact assessment on a PR that changed an endpoint failed because new consumers were added to production between the eval creation and execution.

  • Illustrates: The critical need to keep context graphs up to date with production reality.
  • Lesson: Delays in syncing context graphs with ground truth lead to incorrect data and broken trust.

Actionable Takeaways

  • Immediate:
    • Catalog all production microservices and API endpoints as a foundation for agent context.
    • Ground all agent context in code and production telemetry rather than static documentation.
  • Strategic:
    • Use API Context Graphs to enable coding agents to perform system-wide impact assessments and API design.
    • Catch architectural problems, dependency cycles, and technical debt earlier in the development lifecycle.
  • Questions to investigate:
    • How can agent memory be effectively shared across broader engineering teams rather than individual users?
    • How can business semantic layers be seamlessly integrated into technical API context graphs?

Claims Worth Verifying

  • Over 75% of PRs on top repos affect APIs or integrate APIs. (Statistical claim based on internal Postman repository analysis.)
  • Purely LLM-maintained and written documentation tends to degrade exponentially over time. (Research-backed industry observation.)

Notable Quotes

"Agents are only as good as the context they are given." (at 7:10) "Every single data point that landed on the context graph always had to be grounded down in a hard truth." (at 8:55) "Over 75% of PRs had some effect on the APIs." (at 22:22)

Compressed Summary

  • Coding agents excel at greenfield projects but struggle with complex distributed production systems.
  • Postman built an API Context Graph across 115+ microservices and 4,200+ endpoints.
  • Context graphs must be grounded in hard truth (code and telemetry) to prevent hallucination.
  • 75% of repository pull requests impact APIs or require API integration.
  • API context graphs drastically improve coding agent performance in API discovery, redesign, and impact assessment.
  • Keywords: api context graph, coding agents, microservices, telemetry, impact assessment
  • Core insight: Coding agents in distributed architectures require API Context Graphs grounded in code and production telemetry to effectively handle real-world engineering workflows beyond single-file code generation.

Core insights

6
Practicemedium noveltystrong evidence

Context for coding agents should be derived from hard truth — code implementations and production telemetry — rather than LLM-maintained documentation, because pure-LLM documentation degrades over time without human curation.

Why it matters

It relocates the source of agent context from a human-maintained artifact that rots to machine-generated evidence that stays synchronized with the system, changing what a context pipeline must ingest and how freshness is guaranteed.

Generalization

Any agent operating over a large evolving software system should build its context from extractable ground truth (code, telemetry, schemas) rather than from prose documentation that decays.

Every data point in the context graph must be grounded in hard truth (code or production telemetry).
Open source video
Pure LLM-maintained documentation degrades exponentially over time without human curation.
Open source video
Empirical Resultmedium noveltymoderate evidence

An API Context Graph measurably raises agent scores across API discovery, API design/redesign, and impact assessment while also reducing token overhead, versus Claude with code search alone.

Why it matters

It is a concrete, task-level comparison showing structured graph context beats generic repository code search on both accuracy and efficiency, which is the core claim justifying investment in context infrastructure.

Generalization

Structured, indexed system-topology context can outperform naive code retrieval on cross-service reasoning tasks, and can do so at lower token cost — a benchmarkable claim for context architecture choices.

API context graph significantly improves agent scores across API discovery, API design/redesign, and impact assessment while saving tokens.
Open source video
Mental Modelmedium noveltymoderate evidence

APIs are proposed as the natural context layer of distributed systems: domains and models define system boundaries while API calls define workflows and user journeys, making API topology the right abstraction for agent reasoning.

Why it matters

It offers a specific abstraction boundary for what to model when giving agents system-wide context, rather than dumping repositories or docs into the model.

Generalization

In service-oriented systems, the interface graph (who calls whom, with what shapes) is a compact, high-signal representation of system behavior that can serve as an agent's system map.

In microservice architectures, domains and models define system boundaries, and API calls define workflows and user journeys.
Open source video
Empirical Resultmedium noveltymoderate evidence

Over 75% of PRs on Postman's top repositories either affect API surface areas or integrate new APIs, meaning API context is required for the majority of real-world coding tasks.

Why it matters

It empirically justifies making API-aware context the default rather than a niche capability, and provides a prioritization signal for what context to build first.

Generalization

Survey your own change history before investing in context infrastructure: the dominant change type should determine what the agent's context layer models.

Over 75% of PRs on top repos affect APIs or integrate APIs.
Open source video
Failure Modemedium noveltymoderate evidence

Missing consumer/input-shape context produces delayed, cross-service breakage — adding a property to a task API input schema affected 15 downstream services two weeks later.

Why it matters

It shows impact assessment failures are not immediate compile errors but latent, distributed integration failures, which explains why single-repo agents appear correct while causing downstream damage.

Generalization

Interface changes in distributed systems need consumer-aware reasoning; agents limited to a single repo cannot see the blast radius of a schema change.

A developer added a new property to a task API input schema, but two weeks later, 15 downstream services were affected because input shapes weren't clear.
Open source video
Analyzing all shapes of input and consumer usage via an API Context Graph prevents integration failures and loss of developer trust.
Open source video
Tradeoffmedium noveltymoderate evidence

Skills, MCPs and agent memory are context-bound: skills/MCPs are only as effective as the context supplied to them, and agent memory is siloed per user with no standard cross-team sharing.

Why it matters

It reframes the bottleneck from tooling to shared context substrate — adding more tools or per-user memory does not fix a missing, non-shared system context.

Generalization

Agent capability is bounded by the quality and sharing of its context, not the number of tools; per-user memory architectures cannot substitute for team-level shared system knowledge.

Skills and MCPs are only as good as the context they are provided to.
Open source video
Agent memory is limited to individual users and lacks standard sharing across teams.
Open source video

Deep dives

5

Consumer-aware blast radius prediction for interface changes

Research question

What is the minimum set of graph edges — input shapes, consumer usage, call relationships, persistence — needed to predict the downstream blast radius of an interface change before merge, and how much precision is lost as edges are dropped?

Why

Latent cross-service breakage is the failure mode single-repo agents structurally cannot see; identifying the minimal sufficient edge set tells you exactly what the context graph must extract and keep fresh, and what can be omitted.

A developer added a new property to a task API input schema, but two weeks later, 15 downstream services were affected because input shapes weren't clear.
Open source video
Analyzing all shapes of input and consumer usage via an API Context Graph prevents integration failures and loss of developer trust.
Open source video
Source video

Context graph freshness, drift detection and accuracy decay

Research question

How quickly does agent task accuracy decay as the API Context Graph falls behind live code and production telemetry, and can drift be detected before that accuracy degradation becomes observable?

Why

Grounding in code and telemetry only holds if the graph stays current; without drift detection the pipeline silently reintroduces the staleness problem it was built to eliminate, and teams lose the trust that makes the graph usable.

Every data point in the context graph must be grounded in hard truth (code or production telemetry).
Open source video
Pure LLM-maintained documentation degrades exponentially over time without human curation.
Open source video
Source video

Isolating topology signal from context compression in the token savings

Research question

Do the graph's token savings come from transmitting less text, or from better-structured topology, and does the accuracy advantage survive when graph context and code search are given identical token budgets?

Why

If the gain disappears at matched budgets, the investment is a retrieval-efficiency play; if it persists, the value is genuinely in the graph structure — two different architectures with different cost models.

API context graph significantly improves agent scores across API discovery, API design/redesign, and impact assessment while saving tokens.
Open source video
Source video

Task boundary of graph-context advantage versus code search

Research question

On which coding tasks does an API Context Graph match or lose to plain repository code search, and what task properties predict the crossover point?

Why

Knowing the boundary prevents over-applying graph context and enables a routing decision inside the agent — when to query the graph versus when to fall back to code search.

API context graph significantly improves agent scores across API discovery, API design/redesign, and impact assessment while saving tokens.
Open source video
Source video

Portability of topology-graph context beyond REST microservices

Research question

Do topology-graph context gains replicate in event-driven, data-pipeline, or ML systems, or are they specific to request/response API architectures and their explicit interface contracts?

Why

All reported evidence is REST/API-centric; if the benefit is architecture-specific, teams operating other system shapes should not copy the same context investment pattern.

In microservice architectures, domains and models define system boundaries, and API calls define workflows and user journeys.
Open source video
Source video

Article ideas

4

Stop Writing Docs for Your Coding Agent — Generate a Topology Graph Instead

The choice between prose documentation and extracted context is not a quality difference but a decay-rate difference: LLM-maintained docs rot without human curation while code-and-telemetry-derived graphs stay synchronized, so teams should replace documentation programs with extraction pipelines and freshness SLAs rather than better prompting.

Angle

Frames agent context as a maintained data product with a decay curve, and argues doc rot is an architectural bug, not a discipline problem.

Source video

75% of Your PRs Are API Changes. Your Agent Only Sees One Repo.

Change-history analysis should determine the scope of an agent's context layer: if the dominant real-world change type is cross-service API surface, single-repo code search is structurally the wrong retrieval scope no matter how good the model is.

Angle

Instrument-first argument — measure your own PR taxonomy before choosing a context architecture.

Source video

The Two-Week Bug: Why Agents That Pass Review Break Production

Impact-assessment failures in distributed systems are latent and cross-service rather than immediate compile errors, so coding-agent evaluation must include delayed blast-radius checks; pass rates on compile-and-test are systematically blind to the change class that causes the most damage.

Angle

Forensics of a single schema change that propagated to 15 services, used to argue for a new eval dimension.

Source video

Tools Aren't the Bottleneck; Unshared Context Is

Adding skills, MCP servers, and per-user agent memory does not fix agent failure in distributed systems, because each mechanism inherits whatever context it receives and fragments across users; the leverage point is a shared, team-level system context substrate, not a longer tool list.

Angle

Critique of tool-count-driven agent roadmaps, with a substitution argument for shared context infrastructure.

Source video

Project ideas

4

Blast Radius Gate

gatehouse

A graph-derived consumer list predicts the large majority (>=90%) of services that actually break after an interface change, and gating merges on that list measurably reduces cross-service incidents.

Proof of concept

Build consumer/input-shape/call edges for a multi-service repo set; replay historical schema changes, compare the graph-predicted impacted-consumer list against the post-hoc incident list; then run the gate on live PRs and observe incidents.

Measurement

Precision and recall of predicted impacted services versus observed breakage per change; cross-service incident count and mean time-to-detection before versus after the gate.

Source video

StaleGraph Benchmark

beyond-evals

Agent accuracy on API discovery and impact-assessment tasks degrades monotonically with graph staleness, crossing a usability threshold within a small number of commits or weeks of code change.

Proof of concept

Build an API context graph over a multi-service repository, snapshot it, then advance the code forward while freezing the graph; run an identical task suite at each graph-age offset against a live code-search baseline.

Measurement

Score delta per graph-age step, and the commit count or elapsed time at which graph-augmented accuracy falls below the code-search baseline.

Source video

Unknown Consumer Probe

gatehouse

Graphs grounded only in deployed code and existing telemetry systematically omit newly added consumers, producing false-negative impact assessments, and a hybrid grounding strategy restores detection of those consumers.

Proof of concept

Introduce a new consumer service against a test API, then query a graph-augmented agent for the impacted-consumer list under three grounding configurations: static code only, telemetry only, and hybrid.

Measurement

False-negative rate for the newly introduced consumer and for other consumers absent from telemetry history, per grounding configuration.

Source video

Token-Matched Context A/B

beyond-evals

At equal token budgets, API Context Graph context still outperforms code-search context, showing the accuracy gain comes from topology structure rather than from simply transmitting less text.

Proof of concept

Run the same discovery, design/redesign and impact-assessment task suite under three arms: graph context, code search capped to the same token budget, and uncapped code search; plot score against token spend.

Measurement

Task score at matched token budget and the slope of score-per-token curves across arms.

Source video

Architectural implications

3

Agent context is sourced from an indexed graph built from code and telemetry rather than from maintained documentation.

Before

Agent context came from human-written docs, skills, and per-user memory.

After

Agent context is a generated, LLM-indexed graph grounded in code and production telemetry.

Consequence

Context pipelines must ingest code and telemetry continuously; documentation maintenance burden is replaced by graph extraction and freshness guarantees.

Source video

Context responsibility moves from individual repository scope to cross-service system scope.

Before

A coding agent reasons within a single repository and its local code search.

After

The agent queries a shared API Context Graph spanning 115+ microservices and thousands of endpoints.

Consequence

Multi-service changes become tractable, but the graph becomes critical infrastructure that must be maintained and indexed.

Source video

Graph construction follows a multi-layer mapping: services, endpoint implementations, inter-service calls, data persistence, and client consumption.

Before

System topology existed implicitly across scattered repos and tribal knowledge.

After

Topology is explicit, including dependency cycles and Tier 0/1 clusters.

Consequence

Organizations gain architecture visibility (e.g., spotting bloated outer services) as a side effect of building agent context.

Source video

Tradeoffs and failure modes

3

Grounding vs maintenance overhead

Benefit

Grounding in code and production telemetry prevents stale or hallucinated context.

Cost or risk

It shifts maintenance from human docs to continuous code/telemetry extraction and indexing, which must be kept in sync as the system changes.

Every data point in the context graph must be grounded in hard truth (code or production telemetry).
Open source video
Source video

Shared context vs per-user agent memory

Benefit

A centralized graph provides shared, standard context across teams.

Cost or risk

Per-user agent memory currently lacks standard sharing, so team-level knowledge stays fragmented.

Agent memory is limited to individual users and lacks standard sharing across teams.
Open source video
Source video

Structured graph context vs code search

Benefit

API Context Graph improves scores while saving tokens.

Cost or risk

Requires building and maintaining a graph index; value depends on tasks being API/topology-centric.

API context graph significantly improves agent scores across API discovery, API design/redesign, and impact assessment while saving tokens.
Open source video
Source video

Open questions

4

How is hard-truth grounding kept current as code and production behavior change, and how is drift detected?

Why unresolved

The summary states the grounding requirement and the six-step construction process but does not describe sync, staleness detection, or refresh cadence.

Research direction

Prototype drift-detection between graph state and live code/telemetry, and measure agent score degradation from graph staleness.

Source video

For which tasks does the API Context Graph fail to match or beat plain code search?

Why unresolved

The summary reports improvement across three task types but includes an impact-assessment case that failed because of new consumers, without a full breakdown of failure cases.

Research direction

Build a task-level benchmark contrasting graph-augmented and code-search agents, including cases outside API discovery, redesign, and impact assessment.

Source video

Do new or untracked consumers — those not yet visible in telemetry — get represented in the graph?

Why unresolved

Grounding relies on code and production telemetry, but the summary does not explain how newly emerging consumers are discovered.

Research direction

Test graph completeness by introducing new consumers and measuring whether impact assessment still produces correct downstream lists.

Source video

Does the API-context approach generalize beyond API-heavy architectures (e.g., data/ML pipelines, event-driven systems)?

Why unresolved

All evidence comes from Postman's API-centric microservice environment with 4,200+ REST endpoints and a 75% API-related-PR statistic.

Research direction

Replicate the graph-plus-evaluation methodology in non-REST systems and compare magnitude of agent score gains.

Source video

Key claims

8
factualVerification needed

Postman's internal architecture spans over 115 microservices and 4,200+ REST API endpoints.

Evidence

Postman's internal architecture spans over 115 microservices and 4,200+ REST API endpoints.

Question

What are the exact service and endpoint counts and how were they measured?

Source video
factualVerification needed

Over 75% of PRs on Postman's top repositories affect APIs or integrate APIs.

Evidence

Retrospective analysis of PRs across Postman's top 10 repositories.

Question

How were 'top' repositories selected and how were API-affecting PRs classified?

Source video
causalVerification needed

Pure LLM-maintained documentation degrades exponentially over time without human curation.

Evidence

Pure LLM-maintained documentation degrades exponentially over time without human curation.

Question

Is degradation actually exponential, and over what measurement period?

Source video
comparativeVerification needed

API context graph significantly improves agent scores across discovery, design/redesign, and impact assessment while saving tokens.

Evidence

API context graph significantly improves agent scores across API discovery, API design/redesign, and impact assessment while saving tokens.

Question

What were the exact baseline configurations, scoring rubric, and score/token deltas?

Source video
opinionVerification not requested

Skills and MCPs are only as good as the context they are provided to.

Evidence

Skills and MCPs are only as good as the context they are provided to.

Source video
factualVerification needed

Agent memory is limited to individual users and lacks standard sharing across teams.

Evidence

Agent memory is limited to individual users and lacks standard sharing across teams.

Question

Which agent memory implementations were surveyed to support this generalization?

Source video
opinionVerification needed

Coding agents excel in greenfield projects and single-project fixes but struggle with complex distributed production systems.

Evidence

Coding agents excel in greenfield projects and single-project fixes but struggle with complex distributed production systems.

Question

What benchmark evidence supports the greenfield-vs-distributed performance gap?

Source video
causalVerification needed

Adding a property to a task API input schema affected 15 downstream services two weeks later because input shapes weren't clear.

Evidence

A developer added a new property to a task API input schema, but two weeks later, 15 downstream services were affected because input shapes weren't clear.

Question

What was the propagation mechanism and how were the 15 affected services identified?

Source video

Connections

4