Most conversations about agentic AI start with the wrong question: which model should we use? Models commoditize on a six-month cycle. The team that picked the right model last quarter is one release away from being wrong, and the next release after that. What actually differentiates a production agentic system isn't the model, it's the operational layer around it: tool routing, conversation state, cost controls, guardrails, observability, audit trails. That layer is where the engineering compounds.

This talk is for engineers building agentic systems on real backends, not framework demos, not greenfield AI startups, but the boring middle where most production work lives: a service, an ORM, a queue, a model API. We'll separate durable patterns that survive a model swap from disposable ones you'll delete in six months as models improve, and look at how to design the boundary between them so your stack absorbs capability gains rather than breaking.

The talk has three parts. First, the wrong question, "which model?" dominates the conversation, and what the right question looks like. Second, the durable layer-six patterns shown in framework-free Python, each in roughly 30 lines: tool routing, the agentic loop with bounded rounds, conversation compaction that doesn't corrupt tool-call structure, race-free cost tracking, audit-driven observability, and content moderation as fail-open infrastructure. Third, the disposable layer, retry logic, certain guardrails, aggressive compaction; code that's load-bearing today and will be dead weight in two model generations. We'll cover how to detect that a layer has aged out, and how to keep the boundary clean so removal is a deletion, not a rewrite.

What you'll leave with: a working vocabulary for what's durable vs. disposable in your own stack (more useful, in practice, than the SDK / framework/harness distinction); a public gist of framework-free reference patterns to take home; and a diagnostic for spotting the parts of your current system that are about to age out.

What this talk deliberately avoids: framework recommendations or comparisons (this talk is about the layer frameworks abstracted over), live model demos (capability differences across frontier models are not the point), and product case studies. Patterns are presented stack-agnostically; production grounding is implicit, not the spine.

Audience: backend and platform engineers shipping agentic features in production; technical leads making architecture decisions about whether to adopt agent frameworks. Prerequisites: comfort reading Python and basic familiarity with calling an LLM API. No prior agent framework experience required; this talk works equally well for engineers who've never used LangChain and for engineers ripping it out.