Abstract
Your agent has 100k tokens of context. It still forgets what you told it two messages ago.
Prompt engineering taught us to craft the perfect instruction. Context engineering asks a different question: what does your model need to see and what should it never see at all? It's the shift from writing prompts to designing context.
In this talk, we'll dissect four antipatterns killing your AI agents and the architectural fixes that actually work:
- The Stuffed Prompt : You crammed everything upfront and hoped for the best. But static context doesn't scale. We'll explore dynamic loading and context refinement : fetching what's needed when it's needed, and staying within your context window without losing signal. (And yes, we'll bust the myth that position doesn't matter—models do lose track of what's buried in the middle.)
- The Wrong Tool for the Job : You picked one retrieval method and used it everywhere. But RAG isn't always the answer. Neither are tools. Neither is an exact match. We'll break down when embeddings help, when MCP gives you precision, and when a simple lookup beats both.
- The Goldfish Agent : Your AI agent forgets everything between sessions. Or worse, remembers everything forever. We'll explore short-term and long-term memory, pruning and compaction strategies : what to persist, what to summarize, where to store it, and when to let go.
- The Vibes Eval : You shipped because it "felt right." But you can't improve what you don't measure. We'll build eval strategies that prove your context choices work or expose the tokens you're wasting.
Your context window called. It wants its tokens back!
Bonus: We'll use a coding agent to explain these patterns so you'll learn how they work under the hood ; but everything also applies to AI agents in general.
Interview:
What is your session about, and why is it important for senior software developers?
Everyone's building AI agents. Most of them are broken in the same four ways, and the fix is better context architecture. We'll show, live on stage, how the same agent with the same model goes from unreliable to production-grade just by changing what it sees and when it sees it. Senior developers are the ones making these architectural decisions right now, and most of the available guidance skips the practitioner details. This doesn't.
Why is it critical for software leaders to focus on this topic right now, as we head into 2026?
Because the models are good enough. That's no longer the bottleneck. The teams that are struggling with AI agents are feeding the model the wrong context at the wrong time. Context engineering is becoming the real differentiator between agents that impress in a demo and agents that hold up on a Tuesday afternoon in production. And unlike waiting for the next model release, this is something teams can fix today.
What are the common challenges developers and architects face in this area?
The biggest one: treating the context window like a junk drawer. Teams dump everything they might need into the prompt (system instructions, RAG results, conversation history, tool outputs) and hope the model sorts it out. It doesn't. Then there's the retrieval problem: everyone defaults to embeddings and vector search even when a simple exact match would be faster and more accurate. And finally, memory. Most agents have no memory strategy at all. They either start fresh every session or accumulate everything forever with no sense of what's worth keeping. These aren't edge cases. They're the default for most teams building agents today.
What's one thing you hope attendees will implement immediately after your talk?
Audit your context. Take your agent's prompt, count the tokens, and ask for each chunk: does the model actually need this right now, for this specific task? If the answer is no, pull it out and load it dynamically. That single exercise usually improves agent reliability more than any model upgrade.
Speaker
Patrick Debois
AI Product Engineer @Tessl, Co-Author of the "DevOps Handbook", Content Curator at AI Native Developer Community
Patrick Debois is a practitioner, researcher, and eternal learner exploring how AI agents are reshaping software development — not just for individuals, but for teams and organizations. As Product DevRel lead at Tessl and curator of ainativedev.io, he studies AI-native development patterns, context engineering, and how the context flywheel turns everyday coding into organizational knowledge. He organizes AI Native DevCon and is a frequent conference speaker known for structured, succinct talks. From DevOps to DevSecOps to AI-native dev — Patrick has been at the frontier of emerging practices, always drawn to the same question: how do teams get better, together?
Find Patrick Debois at:
Speaker
Baruch Sadogursky
DevRel Team and Context Engineering Management @Tessl AI, Co-Author of #LiquidSoftware and #DevOps Tools for #Java Developers, Java Champion, Microsoft MVP
Baruch Sadogursky (@jbaruch) did Java before it had generics, DevOps before there was Docker, and DevRel before it had a name. He built DevRel at JFrog from a ten-person company through IPO, co-authored "Liquid Software" and "DevOps Tools for Java Developers," and is a Java Champion, Microsoft MVP, and CNCF Ambassador alumni.
Today, he's obsessed with how AI agents actually write code. At Tessl, an AI agent enablement platform, Baruch focuses on context engineering, management, and sharing. On top of sharing context with AI agents, Baruch also shares knowledge with developers through blog posts, meetups, and conferences like DevNexus, QCon, Kubecon, and Devoxx, mostly about why vibecoding doesn't scale.
Find Baruch Sadogursky at:
Date
Wednesday Mar 18 / 10:35AM GMT ( 50 minutes )
Location
Fleming (3rd Fl.)
