Speaker

Elizabeth Fuentes Leone

Elizabeth Fuentes Leone

Developer Advocate

Developer Advocate

San Francisco, California, United States

Actions

Elizabeth Fuentes is a Developer Advocate and AI engineer specializing in agent harness architecture. Her work spans context engineering, agent memory, security guardrails, and taking agents to production. Through hands-on demos she breaks complex concepts into simple, understandable pieces of code, helping developers build more efficient agents and democratizing the adoption of advanced AI for everyone. Master's in Data Science, bilingual English/Spanish.

Elizabeth Fuentes es Developer Advocate e ingeniera de IA especializada en agent harness architecture. Su trabajo abarca la ingeniería de contexto, la memoria de los agentes, los mecanismos de seguridad y el despliegue de agentes en entornos de producción. A través de demostraciones prácticas, desglosa conceptos complejos en fragmentos de código sencillos y comprensibles, ayudando a los desarrolladores a crear agentes más eficientes y democratizando el acceso a la IA avanzada para todos. Cuenta con una maestría en Ciencia de Datos y es bilingüe (inglés/español).

Area of Expertise

  • Information & Communications Technology
  • Media & Information

Topics

  • Machine Learning and Artificial Intelligence
  • Machine Learning & AI
  • aws
  • AWS Data
  • Data Science
  • Big Data
  • All things data
  • IoT
  • generative ai
  • LLMs
  • LLM app
  • RAG

Sessions

Your AI Agent Isn't Crashing. It's Bleeding Tokens en

Your AI agent does not crash; it gets stuck. It silently produces wrong results when data overflows the context window. It waits forever when an MCP tool calls a slow API. It calls the same tool 14 times because the response said "more results may be available." None of these failures throw errors. They just waste tokens and time.

Three silent failures that cost real money. Context overflow: a tool returns 214KB of logs, the context window fills up, and the agent produces incomplete results with no error. MCP tools hanging: an external API takes 15 seconds and the agent gets a cryptic 424 error. Reasoning loops: ambiguous tool feedback causes 14 retries, burning tokens with zero progress.

I will cover the Memory Pointer Pattern (store large data outside context, return a pointer, based on IBM Research), async handleId for MCP (return job IDs immediately, poll for results, based on Octopus Research), and DebounceHook with clear SUCCESS states that block duplicate calls (14 calls to 2). Each fix includes a live demo with before/after metrics.

You'll walk away with:

• Three production-ready patterns you can implement the same day
• Working code with real metrics for each fix
• Understanding of which failure mode is causing your agent's problems
• Open-source repository with all demos

Most agent talks focus on capabilities. This focuses on efficiency: what agents waste.

Vector, Graph, or Key Value? Choosing Your Agent's Memory en

Your agent works in the demo and forgets the user the next day. Then someone says "add a vector database" before asking which question it must answer.

Pick the store by the question instead. If the agent knows the name of what it needs, a key-value store answers. If it only knows the meaning, it needs vector search. If the answer is a chain of facts, only a knowledge graph gets there. Each store gets a demo where it wins and one where it breaks, so you leave knowing which memory to build first.

What you'll learn:
• Pick key-value, vector or graph memory with one test: does the agent know the name, the meaning or the relationship
• Move key-value memory from agent state to durable storage with a session manager, without changing the tools
• Prototype vector memory in-process and move it to a managed store when it has to survive a restart
• Add graph memory where the answer is a chain of facts, and know what the database and schema cost you
• Run every demo from an open-source repo on the model provider you already use

Outline:
• The agent that forgets you after a restart
• One question that picks the store
• Key-value memory: when the agent knows the name
• Vector memory: when the agent only knows the meaning
• Graph memory: when the answer is a chain of facts
• Which store to build first

Not All Agent Memory Is a Vector Database en

Your agent remembers the user during the demo and forgets them the next day. Models are stateless, and resending the whole history costs tokens on every turn and is gone when the session ends.

This talk is a map of agent memory, drawn with diagrams instead of code. Pick the store by how the agent asks for a memory back: by name, by meaning or by relationship. Then add what every store needs: a rule for what to keep, a gate against memory poisoning, and a record of why the agent decided.

What you'll learn:
• Pick key-value, vector, graph or hybrid memory for each thing your agent must remember, with one question
• Draw the write path and read path that carry a fact from a conversation into storage and back
• Choose who decides what to keep, and know how much control each option leaves you
• Guard a memory store with a write gate and a forget step, sized to the store you picked
• Record decision traces so you can answer why the agent decided, and which decisions trusted a bad source

Outline:
• Why your agent forgets the user
• How a memory gets back to the model
• Four memory types, one question asked four ways
• What to keep, what never to keep, and why it decided
• How to choose, and what this map does not prove

Your Agent Works on Localhost. Now Ship It en

Your agent works on your laptop. Real users need what it never needed there: a session nobody else sees, memory that lasts after the conversation ends, and a guarantee that one user never reads another user's memory.

Deploy the agent you already have to Amazon Bedrock AgentCore Runtime without changing its logic, add short and long term memory with AgentCore Memory, and learn why the user id must come from a verified identity, not from a header the caller sets.

What you'll learn:
• A path from a local agent to a deployed endpoint that leaves the agent's logic alone
• A memory design with a session layer and a long-term layer, stored per user
• The identity rule that keeps one user's memory away from another
• An open source repo with both labs to run in your own account

Outline:
• What Changes When Real Users Arrive
• Deploy the Agent You Already Have
• Memory Inside a Session and Across Sessions
• The User Id Mistake That Leaks Memory
• What the Deployed Agent Did: Logs and Traces
• Resources and Q&A

Context Window Is Full? Let's Fix That en

A tool returns more data than the window holds, and the answer gets worse with no error. A slow API holds the agent. A vague reply makes it call the same tool again and again.

In this hands-on workshop you build the fix for each. Keep big output out of the context window behind a short reference, in one agent and across several. Stop loops with clear tool replies and a hook. Bound slow MCP tools with a timeout or a job id. You run the broken version first, then your fix.

What you'll learn:
• Tools that keep large output out of the window, by hand and with the built-in offloader
• Large data shared across agents without passing it between them
• Clear tool replies plus a hook that caps repeat calls
• A timeout for slow MCP tools, and a start and check pair when the work outlasts the caller
• An open source repo with every module

Outline:
• Setup and the token leaks you will fix
• Keep big tool output out of the window
• Share big data across a team of agents
• Stop repeated tool calls
• Bound slow tools with a timeout or a job id
• Which fix for which leak, resources and Q&A

Build a Voice Agent That Teaches and Remembers en

Most learning apps play the same script for everyone. A voice agent can listen instead. Build a speech-to-speech tutor that holds a spoken conversation, catches grammar and pronunciation slips, and corrects one at a time without breaking the flow.

It looks up the practice story in a knowledge base as a tool, and it keeps memory per learner: their name, the words they struggled with, where they stopped. The next session starts from there.

What you'll learn:
• A speech-to-speech agent design that corrects without breaking the conversation
• A pattern for giving a voice agent retrieval as a tool
• A memory design that keeps each learner separate and resumes the next session
• An open source repo with the full app and its infrastructure as code

Outline:
• One Script for Every Learner
• Speech-to-Speech: The Learner Talks, the Agent Answers Out Loud
• The Story Catalog as a Tool
• A Tutor Prompt That Corrects One Thing at a Time
• Memory per Learner Across Sessions
• What Runs Around the Voice: Sign-In, Live Updates, History
• Resources and Q&A

Keep Conversation and Context Apart, Cut Your Token Bill en

Your agent fetched a large dataset to answer one question, and now that payload rides along in every model call. The instinct is to add more memory. Your agent already has two.

Conversation memory holds what the user said and is recalled by meaning. Large tool outputs need the exact data back, by reference. Keep big outputs outside the context window behind a short reference, keep the conversation in a memory service, and decide where each piece of state lives before you write the tool.

What you'll learn:
• Decide where each piece of agent state lives, by how you need it back, before you write the tool
• Keep large tool outputs out of the context window with built-in offloading, while your tools stay ordinary functions
• Write tools that return a summary, so offloading stays the safety net
• Run conversation memory in a managed memory service and large data in object storage, in one agent

Outline:
• One tool call, and every later call pays for it
• Your agent already has two memories
• Large data: store it outside the window, keep a reference
• Conversation: recall by meaning, per user
• Production: both memories in one agent
• Decide placement before you build

When an MCP Tool Hangs, So Does Your Whole Agent en

Your agent calls an MCP tool. The tool calls an API that is slow, or never answers, and the whole agent waits with it.

Start with a timeout on every tool call: a hang becomes a clear error the agent can handle. When a long-running tool takes longer than the caller will wait, split it: a start call returns a job id, and a check call reports done, failed or timed out. Learn what that split costs in tokens, and where MCP Tasks fits.

What you'll learn:
• A rule for each tool call: let it block, give it a timeout, or return a job id
• A tool timeout on MCP tools, so a hung API ends in an error instead of a stuck agent
• A start and check pair on an MCP server that the agent drives on its own
• End states and cleanup for jobs, so stalled ones do not pile up
• A way to keep status checks cheap in tokens
• What MCP Tasks covers, and how to check its support in your client and server

Outline:
• A slow API blocks the whole agent
• Add a tool timeout first
• When the work outlasts the caller, start a job and check it
• What the job pattern costs in tokens
• MCP Tasks and how to choose
• Resources and Q&A

Your Agent Retries Because the Tool Never Said Done en

Your agent searches flights. The tool lists a few prices, then adds that more results may be available. The agent cannot tell the search is finished, so it searches again. Nothing crashes, but every repeat costs tokens.

The fix starts in the tool: end every answer with a clear done or failed result, so the agent knows when to stop. Then add hooks as safety nets: a duplicate-call hook blocks identical repeats, and a cap limits how often each tool can run. See which guard barely helps.

What you'll learn:
• A way to spot tool answers an agent cannot read as finished
• Tool responses that end in a clear done or failed result
• A hook that blocks identical repeat calls before they run, and where it falls short
• A per-tool call cap that stops a runaway loop
• An order for adding them: fix the answer first, then add the guards
• The open source demo, so you can count the calls on your own agent

Outline:
• Why the agent keeps calling the same tool
• Make every tool answer end in done or failed
• Block identical repeat calls with a hook
• Cap how many times each tool can run
• Which fix to add first
• Resources and Q&A

Stop Paying for Tools Your AI Agent Doesn't Use en

Every tool you give an agent is sent to the model on every call, whether the question needs it or not. A big toolbox with look-alike tools costs tokens and leads to wrong picks.

This session runs the same agent three ways: every tool, a vector filter that keeps the closest few, and a decision model that picks one. You see what each sends, what the selector itself costs, when the right tool gets dropped, and when sending everything is still the right call.

What you'll learn:
• A way to measure what your own tool registry costs per call
• Hook code for both selectors, swappable in the same agent
• A rule for choosing between all tools, a vector filter and a decision model by toolbox size and overlap
• A checklist for tool descriptions that selectors can tell apart

Outline:
• What the model receives
• A hook that sends fewer tools
• Vector filter
• Decision model
• Choosing, and when not to bother
• Resources and Q&A

Is Your Model Routing Better Than a Coin Flip? en

Your agent sends a quick lookup and a systems design question to the same model. A decision model can read each request and pick the model instead, returning a choice and a confidence without writing text. Learn to plug one into an agent as a routing strategy, write the candidate descriptions that act as its policy, send unsure decisions to the strong model, and score the answers against a coin flip and other baselines so you know when routing helps and when your models are too close to bother.

What you'll learn:
• Add a routing strategy that asks a decision model which model should answer
• Write candidate descriptions that work as a routing policy
• Set a confidence threshold with a safe fallback to the strong model
• Build a small evaluation that scores answers, not agreement with labels
• Tell when routing pays off, and when your two models are too close to bother

Outline:
• Two requests, one model
• How a decision model picks the model
• Score the answers, not the labels
• Where routing helps and where it does not
• What no router can see, and a checklist

Break Your Agent Before Production Does en

Your tests cover the happy path, so they pass until production, where tools fail and some users push the agent on purpose. Bad luck: a tool times out or returns a believable wrong value. Bad intent: an attacker escalates over several turns, backs off when refused and tries again.

Chaos testing covers bad luck, red teaming covers bad intent. Both give a different result on each run, so you learn to measure how often the agent holds, not whether it held once.

What you'll learn:
• A chaos test you can add to an agent without changing its tools
• A tool-result check for the believable wrong value the model cannot catch
• A red-team run that generates multi-turn attacks from your agent's own prompt and tools
• A way to read both results as rates across runs
• Open source notebooks for both

Outline:
• Bad Luck and Bad Intent
• Bad Luck: Break the Tools With Chaos Testing
• Bad Intent: Generate Multi-Turn Attacks With Red Teaming
• One Run Is Not a Measurement
• Test Both Before You Ship

Can Your Agent Survive a Multi-Turn Attack? en

Your agent refuses an obvious attack, so you call it safe. A real attacker does not ask once. They escalate over several turns, back off when refused and try a new angle, going after a stored card or a booking past the agent's limit.

Red teaming generates these multi-turn attacks from your agent's own prompt and tools, runs them and scores whether it held. Run it again and the answer can change. Security is a rate you track, not a box you tick.

What you'll learn:
• A red-team run you can point at your own agent's prompt and tools
• Multi-turn attacks for named risks, without hand-scripting each turn
• A way to read a breach score and the cost of each attack
• The habit of tracking a breach rate across runs
• An open source notebook with the full campaign

Outline:
• One Refusal Proves Nothing
• Generate the Attacks From Your Agent's Prompt and Tools
• Run Attacks That Escalate and Back Off
• Score It: Did the Agent Hold, and What Did the Attack Cost
• Security Is a Rate: Run It Again
• Budget Red Teaming Like Any Eval

Prompt Caching Isn't Enough en

An agent turn pays four bills: input tokens, the generated answer, planning cycles and tool calls. Prompt caching discounts the first one only.

This session takes one cache per bill. A response cache returns a stored answer when the question repeats. A reasoning cache reuses the tool path when only the task repeats. A tool-result cache skips the API call when the arguments repeat. You leave with the code for all three as agent hooks and a rule for which one to build first.

What you'll learn:
• A map from each agent cost to the cache that removes it
• Open-source code for the three caches as agent lifecycle hooks, with local notebooks and deployable stacks
• Cold and warm runs from a deployed agent for each cache, so you can run the same comparison on your own traffic
• The reuse technique that made runs longer, so you can skip it

Outline:
• One agent turn, four bills
• Input: prompt caching
• Response cache: the question repeats
• Reasoning cache: the task repeats
• Tool-result cache: the call repeats
• Stacking them

Pick Your Agent's Cache by Its Misses, Not Its Hits en

A semantic cache in front of an agent looks fast on every hit, whatever the store. The lookup runs on every question, though, misses included, and the store also bills while nobody asks.

This session runs the same agent caches on two stores, in-memory ElastiCache for Valkey and serverless DynamoDB vector search, and shows how to choose by traffic shape and miss path. Plus the traps: expired items that still come back, and an index that will not create.

What you'll learn:
• A decision rule for the store: traffic shape and miss latency, not hit latency
• A list of platform checks to run before you plan the stack
• The expiry re-check that keeps a serverless cache from serving stale data
• Open-source CDK stacks for both stores, with the agent and dashboard

Outline:
• Why hits all look the same
• The part that does not depend on the store
• In-memory: ElastiCache for Valkey
• Serverless: DynamoDB vector search
• Decision rule and resources

Edit Your Videos with an Agent Harness on a Local Model en

Turning one recording into a vertical reel takes a creator time. An agent can do it from one request, but it runs ffmpeg on your files, and a prompt cannot stop it from overwriting the original.

Build the video agent on an agent harness, then add control in two places. Hooks inside the agent cancel risky ffmpeg calls and check every file it writes. Strands Box around the agent enforces a policy it cannot change: what it may read, write and reach, and how many tries it gets.

What you'll learn:
• An agent harness that does real work on local files
• Hooks that cancel, check and trace tool calls
• A sandbox policy and the decision log that explains it
• A rule for which control goes in the prompt, a hook or the sandbox

Outline:
• One clip in, one reel out, and what can go wrong (3 min)
• Build the video agent on the harness (8 min)
• Hooks inside the agent (8 min)
• A sandbox around the agent (8 min)
• Prompt, hook or sandbox: where each rule belongs (3 min)

When a Tool Lies, Your Agent Believes It en

Your tests assume tools behave. In production a tool times out, the network drops, or a call succeeds and hands back a corrupted result. That last one is the dangerous one: nothing throws an error, so the agent reports the bad value as fact.

Chaos testing injects those failures on purpose and scores the agent against ground truth. Then fix each failure type in code: check the result against the real record, fall back to a backup provider, and re-run everything to catch regressions.

What you'll learn:
• A chaos test you can add to an existing agent without changing its tools
• Ground-truth evaluators that catch the silent failure a status check misses
• A result-check hook and a fallback hook for both kinds of tool failure
• The habit of re-running the whole suite after every fix
• An open source notebook with the full loop

Outline:
• The Failure That Throws No Error
• Break the Tools on Purpose
• Fix the Silent One: Check the Result Against the Real Record
• Fix the Loud Ones: A Fallback Provider and an Honest Answer
• Re-run Everything: The Regression a Fix Introduced
• Build Chaos Into Your Test Suite

Which Multi-Agent Pattern Does Your Agent Actually Need? en

One agent asked to plan, research, analyze and write in the same context window does each job a little worse. Splitting the work helps only if you split it the right way.

This talk walks through the multi-agent patterns with one use case each: a sequential chain, a parallel fork-join, a critic loop that reviews before it ships, a swarm where agents hand off on their own, and agents as tools under an orchestrator. You leave knowing who decides the path in each, and which to use.

What you'll learn:
• A way to spot the single-agent ceiling in your own agent
• One use case per multi-agent pattern
• A rule for choosing: code decides the path, or the model does
• Open source examples for every pattern

Outline:
• The single-agent ceiling (4 min)
• One job per agent: the sequential chain (4 min)
• Run independent work at the same time: parallel fork-join (4 min)
• Review before it ships: the critic loop (5 min)
• Let the agents choose the path: the swarm (5 min)
• A manager with experts: agents as tools (4 min)
• Combine them, and how to choose (4 min)

Close Enough Is How Your Cache Lies en

A semantic cache decides a hit with one number, and that number is easy to misread. Two questions that differ only by a date look almost the same to it. A store that returns distance looks broken until you flip it. A threshold calibrated on the wrong scale means something else in production.

This session walks through the ways a semantic cache in front of an AI agent serves the wrong answer, and the guard that stops each one, with code from an open-source sample.

What you'll learn:
• A checklist of the ways a semantic cache serves a wrong answer, each paired with the guard that blocks it
• A calibration script that turns labeled question pairs into a threshold on the right scale
• Open-source guard code you can drop into your own cache
• A rule for when a false miss is the right trade

Outline:
• A wrong answer that looks right
• Reading the score correctly
• The dates-and-numbers guard
• Keeping entries valid over time
• Before you share a cache across users
• Checklist and resources

Check the Tool Call Before You Pay for the Answer en

An agent can pick a tool that sounds right but is not, pass a check-out date before the check-in, or turn the city the user named into an airport code. None of these throws an error.

Check tool calls in order of cost: a code check that the expected tool was called, business rules on the parameters inside a hook that blocks the call, and an LLM judge only for the question code cannot answer: do the parameters match what the user meant?

What you'll learn:
• A set of test queries paired with the tool each one should call
• A constraint checker you attach to your agent as a hook
• An intent check that runs only where code cannot decide
• A rule for which check to run on which tool call
• Open source notebooks for every check

Outline:
• The Wrong Tool Call That Does Not Fail
• Check the Tool in Code
• Check the Parameters in Code, With a Hook That Blocks the Call
• Check Intent With an LLM Judge
• Which Check for Which Tool Call

ZZZ REUSAR - Stop Sending Every Tool on Every Call en

Your agent has a big toolbox. Every call sends the description of every tool, whether the user asks about the weather or a hotel room. You pay for all of them, every time.

Send only the tools that fit the question. Embed each tool description once, embed the question, keep the closest few, and a hook swaps them in before the agent runs. Learn this semantic tool selection in Python, see the token counts side by side, and the risk to watch: a tool filtered out cannot be called.

What you'll learn:
• A way to measure what your tool descriptions cost on every model call
• Python code for a hook that keeps only the closest tools per request
• A long-lived agent whose memory survives the trimming
• A check that the right tool still makes the cut
• Tips for tool descriptions that embeddings can tell apart

Outline:
• Every call sends every tool
• Pick the closest tools with embeddings
• A hook that sends only those tools
• Keep the conversation across turns and restarts
• When the right tool gets filtered out
• Resources and Q&A

Agent Speedrun: Idea → Code → Deploy → Observe, Fix → Ship en

You arrive with an idea and leave with a deployed agent. In this hands-on workshop you build one customer service agent with the open source Strands Harness SDK, one layer at a time: the agent loop and tools, a hook that caps runaway tool calls, skills and steering for business rules, and memory that survives a restart.

Then you deploy it to Amazon Bedrock AgentCore Runtime, call your live endpoint and read its logs and traces. With time left, add a specialist agent and automated evals.

What you'll learn:
• An agent you built layer by layer: loop, tools, a hook, skills, steering and session memory
• A live endpoint on Amazon Bedrock AgentCore Runtime that you deployed yourself
• The logs and traces of your own deployed agent
• The open source workshop repo and a self-paced version to run again in your own account

Outline:
• Kickoff: From an Idea to a Deployed Agent
• Module 1: Agent Loop and Tools
• Module 2: A Hook That Stops Runaway Tool Calls
• Module 3: Skills and Steering for Business Rules
• Module 4: Memory That Survives a Restart
• Module 5: Deploy to AgentCore Runtime and Read the Traces
• Module 6 (optional): Hand Off to a Specialist Agent
• Module 7 (optional): Automated Evals
• Wrap-Up and Next Steps

Your Agent's Context Window Is Full. Now What? en es

Long conversations, big tool results and a long tool list all land in the same context window. When it fills, the agent forgets early facts, answers from half the data, or fails on token limits.

This talk maps what fills the window and the built-in fix for each part: conversation managers that trim or summarize history, context offloading that keeps big tool results out by reference, and automatic context management that runs both for you. You leave with a default and a way to test it.

What you'll learn:
• A map of what fills your agent's context window
• The built-in option for each part, and when to use it
• A recall test to run after you trim or summarize
• Open source examples for every option

Outline:
• What fills your agent's context window
• Manage the conversation history
• Keep big tool results out of the window
• Let the agent manage its context automatically
• Pick a default and test it

The Three Hidden Graphs in Every AI Agent en

Ask your agent who you know connected to flights to Spain, and vector search returns the airline, the city and the country as separate pieces. Nothing joins them.

Every agent leans on three hidden graphs: what it knows, what it remembers about you, and why it decided. Make each one explicit in Neo4j. A knowledge graph counts across the whole dataset. Graph memory walks from the pieces to the person. Reasoning memory turns "this source was wrong, which decisions used it?" into one query.

What you'll learn:
• Find the three graphs in your own agent: what it knows, what it remembers, why it decided
• Let the database count and average across a knowledge graph instead of the model reading a few passages
• Answer multi-hop questions over agent memory with similarity plus graph traversal
• Record decision traces with lifecycle hooks, without changing your tools
• Run a reverse audit that finds every decision a bad source touched, in one query

Outline:
• Your agent is already three graphs
• What it knows: count from the graph, not from a few passages
• What it remembers: connect the pieces to the person
• Why it decided: keep the steps, audit in reverse
• What it takes to add them to your agent

Put the Rule Where Your Agent Can't Argue With It en

You put business rules in the system prompt. The agent books past the guest limit, or confirms an unpaid booking because the user says they are the manager. A prompt is text the model reads, not code that runs.

Move the rule into a hook that checks every tool call before it runs. Block the calls that must never happen, like confirming without payment. For limits, steer instead: the hook tells the agent how to comply, it fixes its own call, and the booking completes.

Outline:
• The Rule Was in the Prompt
• Rules in Code, Reasoning in the Model
• Block the Call Before It Runs
• From Blocking to Steering
• Production Patterns and Q&A

When Your Models Disagree, Your Agent Is Guessing en

Which hotel suits a honeymoon? Your database has no single right answer, so the agent picks one and sounds sure. A second agent checking the same data shares the same blind spots.

Ask the same question to models from different families instead, group their answers, and measure how much they agree. Agreement means confident. Disagreement flags a likely hallucination for review. You also learn when not to do this: lookups and business rules are cheaper with a graph query or a hook.

What you'll learn:
• A way to tell a judgement question from a lookup before you pick a defense
• Code that asks several models, normalizes their answers and scores agreement
• A rule for when the extra model calls are worth paying for

Outline:
• One Model, One Confident Guess
• Why a Second Agent Agrees With the First
• Live Consortium Consistency
• When to Use Which Defense
• Picking Models and Routing Reviews

Stop Agents from Choking on Their Own Data en

Your agent reads a large batch of server logs. Nothing errors, and the answer is wrong: the output filled the window and the agent answered from what was left.

Keep big data out of the context window. Store it to the side and hand the agent a short reference that later tools resolve. You see it written by hand, then with built-in context offloading and a tool that computes the answer where the data lives, then shared across a team of agents.

What you'll learn:
• The memory pointer pattern, written by hand and with built-in context offloading
• Why the offloader is the safety net and a selective tool is the real saving
• Data shared across agents without passing payloads between them
• A way to recognize silent overflow in your own traces

Outline:
• The answer is wrong and nothing failed
• Store the data, hand the agent a reference
• Let the framework offload it for you
• Share the data across a team of agents
• Where the stored data lives, and resources

Your RAG Agent Can't Count. A Graph Can en

RAG works for lookups and breaks on questions that need the whole dataset: how many, what is the average, which ones match. The agent sees a few similar passages and answers as if that were everything.

Build a knowledge graph in Neo4j from the same documents with a fixed schema, and let the agent write a read-only Cypher query, so the database counts and averages across every document. See both agents take the same questions, where each one breaks, and when to combine them.

What you'll learn:
• Spot the questions vector search cannot answer: counts, averages and filters across the dataset
• Build a knowledge graph from documents with a fixed schema you control
• Put Text2Cypher behind a read-only agent tool that says "no results" instead of guessing
• Choose RAG, the graph or both for each kind of question

Outline:
• Ask a RAG agent to count
• Turn the documents into a knowledge graph
• Let the agent write the query
• Exact is not the same as right
• When to use RAG, the graph, or both

ZZZ REUSAR - Video Search Agent en

Finding one moment in a video library means turning every video into something searchable: key frames, a transcript, embeddings in a vector database. A model that understands video can skip that for one clip, but it cannot search a whole library.

Build a video agent whose search tool works over an index of frames and transcripts with timestamps, then send one clip straight to a video model. You leave knowing which question each one answers.

What you'll learn:
• A working pattern for turning video into a searchable index with timestamps
• A rule for when to index and when to ask a video model directly
• An agent with a video search tool you can extend
• Open source notebooks for the local and cloud versions

Outline:
• The Moment You Can't Find
• Build the Index: Frames, Embeddings, Transcript, pgvector
• The Agent's Video Search Tool
• Ask a Video Model Directly
• Which Question Needs Which, and Moving It to Containers
• Q&A

Your AI Agent Isn't Crashing. It's Bleeding Tokens en

Your agent does not crash. A tool returns a huge log dump, the window fills, and the answer gets worse with no error. A slow API holds the agent until the caller gives up. A vague tool reply makes it call the same tool again and again.

Each leak has a fix you can rerun: keep large output out of the context window behind a short reference, bound slow MCP tools with a timeout or a job id, and stop loops with clear tool states and a hook that caps calls.

What you'll learn:
• A way to tell the leaks apart from what the trace shows
• Large tool output kept out of the window behind a short reference
• A tool timeout for slow MCP tools, and a job id when the work outlasts the caller
• Clear tool replies plus a hook that caps repeat calls
• Open source code for every fix

Outline:
• How an agent wastes tokens without an error
• Big tool output: keep it out of the window
• Slow tools: stop waiting on them
• Repeated calls: tell the agent it is done
• Which fix for which leak, and resources

RAG vs GraphRAG: Cuando los Agentes Inventan Respuestas en es

Tu agente RAG parece inteligente hasta que le pides contar algo. Pregunta: cuantos elementos cumplen X? RAG tradicional inventa: aproximadamente 45-50. La respuesta real? 133. La similitud vectorial no puede contar, agregar ni razonar entre relaciones.

El problema fundamental: RAG tradicional recupera fragmentos de texto por similitud y pide al LLM sintetizar respuestas. Esto funciona para consultas simples pero falla sistematicamente en cuatro tipos: conteo, agregacion, razonamiento multi-hop y deteccion fuera de dominio.

En esta charla veras:

- Por que RAG tradicional alucina en consultas estructuradas
- Como Graph-RAG construye grafos de conocimiento automaticamente con neo4j-graphrag
- Patron Text2Cypher: lenguaje natural a consultas precisas de base de datos
- Comparacion lado a lado con consultas identicas mostrando fabricacion de RAG vs precision de Graph-RAG
- Patrones de implementacion para produccion con herramientas open-source

Te llevaras:

- Implementar Graph-RAG con Neo4j y extraccion automatica de entidades
- Aplicar generacion de consultas Text2Cypher para obtener respuestas precisas
- Evaluar cuando usar RAG vs Graph-RAG con un framework de decision concreto
- Codigo open-source adaptable a cualquier dominio con datos estructurados

One Guardrail Won't Stop Your Agent Hallucinating en

Your booking agent has its rules in the system prompt. It still books past the guest limit and confirms a booking nobody paid for. One guardrail covers one failure.

See a booking agent on Amazon Bedrock AgentCore where every layer runs together. Business rules live in a DynamoDB table you edit without a redeploy. A broken rule returns a steering message, so the agent fixes its own request. Hooks block what must never happen. Answers come from real data and a knowledge graph.

Outline:
• The booking agent that ignores the rules in its prompt
• How the agent runs on Amazon Bedrock AgentCore
• Business rules in a database, not in the prompt
• Block what must never happen with hooks
• Answers from real data, not guesses, with GraphRAG
• The full booking flow on the deployed agent
• Resources and Q&A

Stop AI Agent Hallucinations With Code, Not Prompts en

Your agent makes up statistics the database never had, picks the wrong tool from a crowded list, and books more guests than the room holds. Rewording the prompt fixes none of it.

In this hands-on workshop you fix each failure in code: compute answers in a knowledge graph, send the model only the tools that fit, flag answers when several models disagree, enforce rules in hooks it cannot bypass, and steer it to correct its own request. Then you run it in production with memory.

Outline:
• Introduction: Why AI Agents Hallucinate Differently Than LLMs
• Demo 00: Strands Agents Primer
• Demo 01: Graph-RAG vs. Standard RAG
• Demo 02: Semantic Tool Selection
• Demo 03: Multi-Agent Validation with a Model Consortium
• Demo 04: Neurosymbolic Guardrails
• Demo 05: Native Steering
• Demo 06: Production on Amazon Bedrock AgentCore
• Demo 07: AgentCore Memory Across Sessions
• Workshop Recap + Resources
• Q&A

Two Agents, Same Answer, One Is Wasting Your Money en

Agent A and Agent B answer the same travel question correctly. A calls only the tools it needs. B also calls a currency tool nobody asked for and repeats the flight search. A pass/fail test passes both, and you pay for B's extra calls every run.

Build evals that tell them apart: a model that grades the answer against a written rubric (LLM-as-a-judge), a test for that judge's bias toward longer answers, and a hook that records every tool call so you can grade the path (trajectory evaluation).

Outline:
• Why Pass/Fail Can't See a Wasteful Agent
• Grade the Answer With a Written Rubric
• Check the Judge Before You Trust It
• Record Every Tool Call the Agent Makes
• Grade the Path and Flag Risky Runs
• Repeat the Eval, Then Ship

Your Agent Lies and Passes Every Test en

Your agent recommends a flight that was never in the search results. The test passes. It only checked that an answer came back.

Grade what the agent said instead. An LLM-as-a-judge scores the answer against the tool results, with no labeled data. Split the reply into single claims to find the invented fact. Score every turn, because a conversation can start safe and drift. Then move the check into a hook that flags ungrounded answers and blocks risky tool calls.

What you'll learn:
• A groundedness rubric you can point at your own tool results
• A claim checker that names the exact fabricated fact
• A per-turn safety eval that catches drift in long conversations
• Agent hooks that flag ungrounded answers and block risky tool calls
• Open source notebooks you can run against your own agent

Outline:
• The Test Passes, the Answer Is Made Up
• Check the Answer Against What the Tools Returned
• Find the Exact Fact the Agent Invented
• A Safe First Answer Is Not a Safe Conversation
• Move the Checks Into the Agent Loop
• Takeaways and Q&A

A Better Prompt Won't Fix Your Agent. A Better Harness Will en

An agent that works in a clean demo meets what it never saw there: memory it should not trust, untrusted content it does trust, multi-step tasks where a step silently fails, and the same work redone on every call.

No prompt fixes these. Code in the agent harness does: a check before every memory write, a gate on the dangerous tool, a verifier that reads the backend and retries only what failed, and a tool the agent writes once and reuses.

What you'll learn:
• A way to diagnose production failures before choosing a fix
• A memory-write guardrail and a tool-boundary gate you can add to any agent
• An execute-then-verify pattern for multi-step tasks
• The honest cost of each control: what it cannot catch and what it adds in tokens
• An open source repo that reproduces each failure and its fix

Outline:
• The Demo Worked. Production Did Not
• Break It on Purpose to See Where It Fails
• Check the Fact Before It Goes Into Memory
• Block the Action a Poisoned Memory Asks For
• Verify Each Step Against the Backend
• Let the Agent Write the Tool It Keeps Needing
• Which Harness Control Fits Which Failure

NODES 2026 Sessionize Event

November 2026

CloudX 2026 Sessionize Event

September 2026 Santa Clara, California, United States

AI Engineer Worldsfair SFO 2026

Agent Speedrun: Idea → Code → Deploy → Observe, Fix → Ship

June 2026 San Francisco Cuaxusco, Mexico

AI Engineer Worldsfair SFO 2026

The Infinite Context Window Is a Myth: Context Engineering for AI Agents

June 2026 San Francisco, California, United States

PyconUS 2026

How to Build Your First Real-Time Voice Agent in Python (Without Losing Your Mind)

May 2026 Long Beach, California, United States

AgentCon - Silicon Valley Sessionize Event

May 2026 San Francisco, California, United States

Orlando Code Camp 2026 Sessionize Event

April 2026 Sanford, Florida, United States

DeveloperWeek 2026

Master Vibe Coding and Deploy AI Agents to Production

February 2026 San Jose, California, United States

PyLadies San Francisco @ LinkedIn

Have a Conversation with Your Videos: Video Analysis Agents in Python"

January 2026 San Francisco, California, United States

Python Meetup - Extending AI agents: Custom tools and Model Context Protocol

Extending AI agents: Custom tools and Model Context Protocol

November 2025 San Francisco, California, United States

Tech Talk: Moving Agents to production with Strand and Agentcore

Tech Talk: Moving Agents to production with Strand and Agentcore

October 2025 San Francisco, California, United States

DevFest Fresno - Build with AI Sessionize Event

October 2025 Fresno, California, United States

DataWeek 2025 Sessionize Event

September 2025 Santa Clara, California, United States

MCP Dev Day 2005

Tech Talk: Extending AI agents: Custom tools and Model Context Protocol

August 2025 San Francisco, California, United States

AICamp Women in AI 2025

Agentic AI: Designing with Intelligence & Autonomy.
Description: About building AI agents for early-career developers with Strands Agents.

August 2025 Palo Alto, California, United States

Meetup - AWS User Group Ajolotes Ciudad de Mexico

Agentes Multi-Modales con Python: Procesando Imágenes, Videos y Documentos en Pocas Líneas de Código

August 2025 Mexico City, Mexico

Pycon US 2025

Construyendo un Buscador Multimodal: Combinando Texto e Imágenes para una Búsqueda Inteligente.

En el mundo actual basado en datos, procesar y analizar eficientemente grandes volúmenes de datos es crucial para muchas aplicaciones. Exploremos juntos cómo crear y administrar embeddings de texto e imágenes para búsqueda de similitudes en una base de datos PostgreSQL. Nos sumergiremos en un ejemplo práctico utilizando Python para demostrar cómo pueden crear buscadores que empleen lenguaje natural.

May 2025 Pittsburgh, Pennsylvania, United States

AWSome Women Summit Latam 2025 Sessionize Event

March 2025 Lima, Peru

AWS Community Day Chile 2024 Sessionize Event

November 2024 Santiago, Chile

AWS Community Day Argentina 2024 Sessionize Event

September 2024 Buenos Aires, Argentina

KCD Argentina 2024 Sessionize Event

May 2024 Buenos Aires, Argentina

AWS Community Day 2024 Sessionize Event

April 2024 Lima, Peru

Nerdearla Chile 2024 Sessionize Event

April 2024 Santiago, Chile

AWS Women Summit 2024 Argentina Sessionize Event

March 2024 Buenos Aires, Argentina

AWS Community Day Uruguay 2023 Sessionize Event

November 2023 Montevideo, Uruguay

CodeCampSDQ 2023 Sessionize Event

October 2023 Santo Domingo, Dominican Republic

CDK Day 2023 Sessionize Event

September 2023

AWS UG Perú Conf 2023 Sessionize Event

September 2023 Lima, Peru

PyDay Chile 2023 Sessionize Event

June 2023

Elizabeth Fuentes Leone

Developer Advocate

San Francisco, California, United States

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