Every mobile AI agent today — whether it's automating tests, navigating apps, or completing tasks on behalf of a user — starts every session completely blind. It sees the screen, reasons about what to do, acts, and then forgets everything the moment the session ends. The next time it encounters the same cookie consent dialog, the same slow-loading screen, the same unexpected popup, it figures it out from scratch. Again. Every single time. This talk explores what happens when you give a mobile agent memory — not chat history, not RAG over documents, but structured recall of how it has interacted with real device interfaces over time. What screens has it seen before? What actions worked? What failed? What changed between app versions? We'll walk through the architecture of a memory system built for vision-based mobile agents: session recording at each execution step, checkpoint management for recovery, screen fingerprinting for cross-session identity, and a context compiler that turns thousands of historical interactions into a compact, useful prompt — all without blowing up your LLM token budget. Using real examples from production mobile test automation at enterprise scale, we'll show how memory turns a stateless agent into one that gets measurably smarter with every run — fewer retries, faster execution, self-healing across app updates, and recovery from unexpected UI states in one step instead of ten. We'll also look ahead: if agents are going to operate our phones, our desktops, and eventually our physical environments, what does the memory infrastructure need to look like? How do you fingerprint a screen that changes every time due to dynamic content? How do you compress 500 sessions into something an LLM can consume in 2,000 tokens? And what happens when multiple agents need to share memory while working on related tasks across different apps? This isn't a talk about prompting tricks or model selection. It's about the infrastructure layer underneath mobile agents that nobody is building — and that determines whether your agent is a clever demo or something an enterprise will actually trust in their CI pipeline. Who should attend: Android and iOS engineers building or evaluating AI-powered automation, developers working on mobile agents or computer-use agents, QA engineers interested in where test automation is heading, and anyone curious about what it actually takes to make AI agents reliable on real devices. What you'll take away: A concrete architectural pattern for agent memory (session recorder, checkpoint manager, context compiler, coverage tracker), a framework for measuring whether memory is actually helping (progress work vs. recovery work vs. wasted work), and an honest assessment of what's hard about this problem and what's still unsolved.