Talia Kohan (Nassi)
Staff Developer Advocate @ Postman
Los Angeles, California, United States
Actions
Talia Kohan (Talia Nassi) is a Staff Developer Advocate at Postman, helping developers build, test, and scale APIs and AI-powered applications. A global keynote speaker, she works closely with the developer community to share best practices in modern software development and foster innovation through practical education and collaboration.
Links
Badges
Area of Expertise
Topics
Congratulations, you broke everything: How to build context-aware agents
Most AI coding tools can generate code. Few can answer a more important question: what else needs to change?
In modern systems, a single API change can impact specifications, collections, backend services, frontend applications, tests, CI/CD pipelines, databases, documentation, and infrastructure. Experienced engineers know that implementing the change is often the easy part. Understanding its downstream impact—and updating every dependent system correctly—is where the real work begins.
This talk explores how autonomous agents can move beyond code generation by leveraging a Context Graph built from the artifacts engineering teams already maintain: API specifications, collections, tests, environments, source code, and runtime dependencies. Rather than operating on individual files in isolation, these agents can reason about relationships across an entire system.
Through real-world engineering workflows, including migrations, contract drift remediation, dependency analysis, large-scale refactoring, and test generation, we'll examine how context-aware agents can identify affected components, coordinate changes across repositories, validate outcomes, and produce reviewable pull requests.
You'll see why context is often the limiting factor in autonomous software development, and how APIs provide a durable foundation for building agents that understand the architecture, dependencies, and operational reality of modern software systems.
Coding is Easy. Context is Hard.
Your AI assistant just wrote 500 lines of flawless code. Unfortunately, it had no idea it just broke three services, invalidated two SDKs, failed a deployment pipeline, confused your API consumers, and made your on-call engineer question every life decision that led them here.
The problem isn't that AI can't write code. The problem is that most AI agents are brilliant interns on their first day: fast, enthusiastic, and completely unaware of how your systems actually work.
Modern software is a giant web of dependencies. APIs connect to services. Services run on infrastructure. Infrastructure feeds telemetry. Gateways enforce security. SDKs and documentation power developers. Tests prove everything still works. Change one thing, and suddenly everything has an opinion.
This session explores what happens when we give AI agents the missing ingredient: context. We'll dive into the architecture behind truly context-aware engineering systems, including how API knowledge graphs, catalogs, source control, Kubernetes environments, observability platforms, and runtime metadata create a living map of an organization's technology ecosystem.
From there, we'll explore how AI agents use that context to move beyond autocomplete and become actual engineering collaborators. Agents can understand the blast radius of a change, coordinate updates across repositories, generate SDKs and documentation, execute browser-based validation, trigger automated workflows, securely access enterprise systems, communicate through AI-native gateways, and run production-grade agent workloads.
Because the future of AI engineering isn't an AI that writes more code. It's an AI that finally understands what that code is connected to.
One Terminal, The Entire Agentic SDLC
Has this ever happened to you? You pick up what looks like a straightforward coding task: update an API, run the tests, open the PR, and move on. Then, a few nights later, you’re paged for an incident tied to that change. The update worked exactly as expected in your service, but it silently broke a dozen downstream consumers you didn’t know existed.
You even asked your coding agent to verify that the change wouldn’t break anything, and it did, within the boundaries of the repository. That’s the problem. A repository can show an agent what an endpoint calls, but it rarely reveals the full dependency graph: who calls that endpoint, which consumers rely on an undocumented field or side effect, whether those consumers are still active in production, where they’re deployed, or which team owns the pager when they fail. The agent reasoned accurately about the systems it could see. It just didn’t have enough operational context to understand the true blast radius.
In this talk, we’ll work through that scenario as an agentic software development lifecycle. We’ll give an agent an API requirement and follow it through implementation, a collection, tests, CI, and monitoring, all in the terminal. You’ll see the agent use task-specific skills to carry out each step, inspect the results, and fix what fails.
Then we’ll change the requirement. Before editing the API, the agent will query a Context Graph to find affected callers and consumers beyond its local checkout. We’ll use those findings to decide what needs to change, update the implementation and its supporting tests and contracts, and check the results again. We’ll also show where an engineer needs to review the evidence and coordinate with the teams that own affected services.
You’ll leave with a real world use case of what an agentic SDLC requires across the whole API lifecycle: instructions that help an agent do the work, checks that expose failures, and enough context to catch consequences outside the repo before they become an incident.
Talia Kohan (Nassi)
Staff Developer Advocate @ Postman
Los Angeles, California, United States
Links
Actions
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top