Reversim 2026

Paranoia Driven Development: Learning from Production Incidents

I used to think being a good engineer meant writing code that worked. Then I started working on systems that move real money. When the cost of a mistake is that high, "move fast and break things" stops being funny. This talk is about Paranoia Driven Development: treating fear of failure not as anxiety, but as an engineering discipline. Through one true, slightly absurd personal story, I'll walk through the anatomy of a production incident – how it really begins, why our first instinct is usually the wrong one, why the bug you see is rarely the real cause, and how to stay prepared long after the incident is "over." Although the story comes from fintech, the mindset applies to any production system where failure has consequences. You'll leave with a different way of thinking about production incidents – and about the software you build every day.

Karina Nosenko

Keynote

Agentic Web - Building the Future

For thirty years we built the web for human eyes. That era is ending. Agents now consume the web headlessly and hand us only the last mile, visually. AI apps are the new browsers. While everyone watched coding agents, the bigger shift was happening to the web itself. There's a strange pattern to every shift this big: the infrastructure for it gets built before the thing it supports actually exists. You don't build for the future, you build the future itself. The catch is that conviction alone isn't enough - you have to build a vision on exisiting tech primitives. This talk is about the agentic web, how to recognize a revolution while it's still forming, and how to lead it rather than merely survive it. From Shopify to GitMCP, MCP Apps, and founding Ora, this is what building the agentic web early taught me. Shape a revolution instead of adapting to it. Understand how to build an agent-ready future, bet on tomorrow's tech, and help lay the tracks the rest of the world will run on.

Liad Yosef

Stop Lying to Your Agent! Build a Service Graph It Can Trust

Our best engineer never sleeps. It's first responder when production breaks, QA when a bug shows up, architect when we redesign, and the knowledge base we ask anything — our go-to on every topic. It's also an AI agent, and it's only as good as what it knows about our system. What it knew, at first, was lies: decayed diagrams, drifted names, dependencies that don't exist. This talk is how we gave it architecture knowledge it can trust. We used LLMs to extract a dependency graph of 158 microservices from 52 repos — and the extraction was the easy part. I'll walk through the trust model that survived production: separating what the code says from what live systems confirm, tagging every edge with provenance and confidence, keeping contradictions as claims instead of overwriting facts, and gating what the agent may write back. Full of gotchas, postmortem-style war stories (hallucinated log keys, phantom edges), and insights that stick the next time an agent answers with full confidence.

Alon Nativ

Server-Side Apps: The Real Alternative to React

A new breed of frontend frameworks is proposing an alternative to client-side and server-side rendering and server-side rendering. In both, the app code runs on the browser, with all the problems client-side apps have - large bundle sizes, the need to store state and sync it with the server, etc. These frameworks - chief among them HTMX and Hotwire/Turbo - propose a different solution, harking back to the original web days, but with the added dynamism enabled by modern browsers. Join me to learn how you can write server-side apps - where most of the app code is server-generated HTML, yet has the dynamism and interactivity of client-side apps without the pains that come with running large amounts of code in the browser.

Gil Tayar

From a Minute to a Second: The Hardcore Engineering Behind Making Video Generation Fast

Generating a few seconds of video can easily take a minute of compute. Closing that gap isn't AI - it's engineering. A layered stack of low-level optimizations, each with real tradeoffs, and several that will surprise you even if you've been doing systems work for years. This talk opens the black box of video inference optimization: attention kernels, quantization, compilation, CUDA graphs - what they actually buy you, what they silently cost you, and where the hardest problems come from places nobody warned you about. Based on hands-on experience optimizing LTX Video's inference engine.

Barak Yoresh

Taste: The Engineering Skill Nobody Taught Us

Suddenly everyone is talking about “taste.” As AI makes writing code dramatically cheaper, more and more people argue that an engineer’s real value is shifting from writing code to exercising good judgment. “Taste” has become one of the most talked-about ideas in software engineering, but what does it actually mean? I don’t claim to have the answer. Instead, let’s explore the question together by examining some of the most influential engineering decisions in software history, from Git and Unix to SQLite, Go, and beyond. We’ll look for recurring patterns, challenge our assumptions, and discuss why this conversation has become so relevant in the age of AI. Hopefully, we’ll all leave with a richer vocabulary for thinking about engineering judgment, and maybe even a few ideas for developing it ourselves.

Alon Wolenitz

Accidental Conversion: When AI Completes Actions Users Never Chose

At Amazon Devices, I worked on a product launch where conversion looked strong, and we were sure we found a winning solution. Until we started reading user forums. People were asking questions about features that didn’t exist in the product they bought, because they hadn’t realized they selected the wrong model. I came to call this Accidental Conversion: when a product successfully drives an action before the user has fully made the decision behind it. The metrics said success; users were confused. For 2 decades, we taught products to remove friction. AI is accelerating that trend, making systems better at predicting, recommending, & completing actions. But it also creates a new blind spot: products can become increasingly good at getting users to “yes” before they actually decided. In this talk I'll share 2 Amazon cases where healthy metrics hid this pattern, what it costs when you miss it, and how to think about conversion differently in products where AI is doing more of the work.

Noa Sabar Dvoskin

Scaling Waze Road Closure Data Ingestion with GenAI

For Waze, accurate road closure data is critical. Minor errors can cause failed routes and erode user trust. Much of this data comes from public sources. However, the highly flexible and diverse nature of these data sources creates a severe bottleneck, making it difficult to scale via traditional methods. To overcome this, we deployed a GenAI powered pipeline, leveraging few-shot in-context learning to autonomously translate data into standardized spatial objects. This talk unpacks how we shrunk feed onboarding to minutes. We will explore the architecture behind this scale-up, detailing our rigorous Human-in-the-Loop (HITL) rollout, and offer practical lessons on building decoupled 'LLM-as-a-Judge' evaluation suites to monitor online quality and accelerate iterative model optimization.

Lital Goldhaber Hana

Rubber Ducking for LLMs

Ever wondered why Rubber Duck Debugging actually works? It doesn't work because the duck is smart. It works because it forces us to unpack the implicit knowledge we have about our code, expose hidden assumptions, and make what's obvious in our own minds explicit to something with zero prior context. Turns out, LLMs are the most sophisticated rubber duck we've ever had. In this talk, I'll introduce the Cognitive Empathy Framework - a practical model I've been developing, inspired by cognitive psychology, for designing prompts and context for AI coding agents. We'll use real AI engineering examples to explain why techniques like prompt engineering, context engineering, and iterative refinement work so well, and explore the principles that help both humans and AI systems build understanding. You'll leave with practical, scientifically backed techniques for writing better prompts, designing more effective AI systems, and collaborating more successfully with LLMs.

Moran Weber

I Have a Full-Time Job. My Side Projects Don’t

There has never been a better time to build something on the side. AI has dramatically lowered the cost of turning an idea into a real product, and suddenly everyone is trying. But when you already have a full-time job, building is only half the challenge - the real constraint is your attention. Drawing from my own experiments building and running multiple side projects with AI, I’ll share what worked, what failed, and what I learned along the way: how to choose projects that won’t become a second job, delegate more than just coding to AI, automate as much as possible, and build the tools and controls that let you keep things running without constantly being there.

Shem Magnezi

LLMs Stole the Fun, Then Gave It Back With Better Data

I became a data scientist because I liked getting my hands dirty with data, building models, and slowly turning a mess into something understandable. Then LLMs arrived and seemed to reduce all of that to typing a prompt. I was not impressed. What changed my mind was not chatbots, agents, or generated code. It was structured output. LLMs can turn sources that were previously unusable at scale into datasets we can validate, query, visualize, and learn from. In this talk, I will move from a tiny extraction example to analyzing hundreds of podcast episodes, then mapping the characters, travel, technology, and plot of my favorite sci-fi books, and finally show how the same pattern applies to real security work at Neo Security. This is how LLMs made data science fun for me again, not by giving me answers, but by helping me create entirely new data.

Dean Langsam

Rebuilding the Software Factory: The Blueprint for Agentic Builders

The era of human-written code and manual pull request reviews is over. In the shift toward Agentic Software Engineering, we are no longer typists; we are orchestrators. A new role has emerged: the "Builder." Builders are highly creative and independent, acting as agent coaches who manage intent and strategy. However, if multiple independent builders unleash fleets of autonomous agents without governance, the result is a mess - repeated code, duplicated functionlity and architecture and infinite technical debt. This talk explores how to rebuild the "software factory" to support these builders. Just as construction workers need an architectural schematic to avoid colliding, agentic builders need a shared digital blueprint - a continuously updated metamodel of the system. We will cover the necessity of deterministic CI/CD guardrails, unified agent infrastructures, and how to define the boundaries that allow builders to innovate safely at maximum speed.

Tal Salmona

Some Assembly Required: The Skill of Not Falling for the AI Monster You Built

Be honest: that last project you built with AI? You think it's a lot better than it actually is. So does the developer next to you, and so does every product manager who ever fought for their favorite feature.   It's not ego, it's the IKEA effect: a bias quietly sabotaging the best builders in tech. The more effort you pour into something, the more sure you are it's brilliant, and the less you can walk away. AI poured gasoline on it, whether you're a product manager, a developer, or just someone who loves to build, you now fall in love faster than ever, and end up defending bloated, unmaintainable things you'll be cursing in a month.   This talk is your toolkit for dodging that trap: how to catch it in yourself, and exactly what to do instead. Because here's the part nobody wants to hear: like it or not, the human product skills are now the most important ones you've got.   AI is just a tool. Falling in love with the problem instead of your solution - that's the golden skill.

Elena Levi

Teaching AI Glasses to Track a Drawing in the Making

What does it take to turn AI glasses into your very own drawing teaching tool? We integrated Meta Ray-Ban AI glasses into our hand-drawing teaching app, in order to provide for the app’s users a complete, drawing-focused timelapse of their sketching process from their own POV. This turns a standard Computer Vision task into an interesting challenge by removing multiple common simplifying assumptions: track a feature-poor, partially-occluded, moving object from a moving perspective, at low FPS, as it is being created from scratch, all while a highly-similar but unwanted target - the app’s reference drawing - is in view. In this session we'll discuss integrating the new AI Glasses technology into our app, and solving this novel problem via semantic segmentation models, a custom processing and stabilization pipeline, and strongly in-domain data.

Gil Peled

The Layoff Playbook Nobody Gives You

Getting laid off in tech is tough, but the "toxic positivity" and social media noise that follow can be even harder. Drawing from personal experience and facilitating workshops for impacted tech workers, this talk offers a practical, honest look at navigating job loss, detoxing from LinkedIn pressure, and separating your self-worth from your professional identity.

Yuval Simhi

Who's Running Something on Our Servers at 3 AM?

3:12 AM. A cloud cost alert wakes up the on-call engineer. No deployment is running, no campaign is live, our users are asleep. And yet - something on Any.do's servers is working overtime, and burning money. This is a true story from July 2026, and you'll experience it exactly the way we did: without knowing the ending. We'll follow the investigation clue by clue - the graphs, the logs, the dead ends, and one plot twist nobody in the room will see coming. At every step, you're invited to play detective and guess what's really going on. Bring your detective instincts. The solution is only revealed in the room.

Yoni Lindenfeld

Reward Hacking: Fusing the Cultures of AI and Security Research

AI researchers and security researchers never really had a reason to collaborate closely - until the agentic revolution. In this lightning talk we - a cyber researcher and an AI researcher - will share what it looks like when we work together to build the world's best AI hacker. We'll talk about where our instincts, tools and approaches clash, what each field can learn from the other and how we facilitate this joint learning. We hope that the lessons we share will be a useful blueprint for building teams that are true mixtures of experts.

Dan Padnos

Elad Meged

A Yak Walks into a Standup

Seth Godin gave developers a rule in 2005: don't shave that yak. As a team lead, I found a good reason to break it. My engineers' status updates kept opening the same way: a smile, then a story about the yak they had to shave before getting to the actual task. Not the state I wanted my team in. But every story named something missing: a tool, a piece of infrastructure, a conversation that never happened. Naming it was the first step to fixing it. In five minutes we'll get introduced to the term through a webcomic and an early-2000s sitcom. We'll see what the standard advice throws away, and how a yak story turns into better tooling and the architecture conversations nobody schedules. You'll walk out knowing what to ask when the next yak story starts.

Amit Zur

Your Experts Are Not Training Data

"We need domain experts." Everyone agreed. Nobody knew what we should actually ask them... While building AI financial and business advisors at Intuit, we learned that the hardest problem wasn't prompting the LLM, it was figuring out how to capture our experts' knowledge in a way that actually improves the product, benefits customers, and doesn't exhaust our advisors (or ourselves). In five fast minutes I'll share the experiments that surprised us: why our "golden answer" wasn't so golden, why comparing AI responses beat writing answers from scratch, how disagreement became useful data, and why a simple yes/no question sometimes taught us more than an expert paragraph. Most importantly, how we realized we weren't looking for one perfect answer, we were discovering what "good advice" actually means. Whether your experts are accountants, doctors, lawyers or your company's "person who knows everything," you'll leave with practical ideas for turning human expertise into better AI.

Shirli Di-Castro Shashua

Beyond LLM-as-a-Judge: Math-Based Response Evaluation

What if you could learn how to read your AI model's pokerface, and predict the likelihood of bluffing, even before he lays his cards on the table?

Elad Laor

Who Wants to Be an AI Practitioner? The Million-Token Gameshow

Welcome to the Reversim ultimate tech reality check game: "Production Drop or AI Flop?" In this fast-paced interactive lightning session, a live gameshow is coming straight to the crowd. Get ready to answer the ultimate question: Are these genuine engineering wins, or just incredibly expensive architectural illusions? The Generative AI gold rush has turned engineering ecosystems into a high-stakes guessing game. Driven by relentless industry FOMO, developers are treating basic API wrappers like architectural triumphs, PMs are shipping features based entirely on hype metrics, and Data Scientists have traded rigorous statistical validation for the chaotic dopamine rush of prompt engineering. The industry has become so blinded by the shiny brilliance of LLMs that deterministic bounds have been completely traded away for probabilistic, "vibes-based" outcomes. No marketing fluff, no boring slides—just a brutal, hilarious, and deeply necessary intervention for a room full of builders.

Rotem Pinchover

How to Navigate T-Rex-Sized Codebases

Google Chrome’s Dinosaur game is one of the most popular in the world, everybody has seen it at least once, but did you really see it? I mean, it’s codebase, Chromium is open source, so let's start digging and find some dinosaur bones 🦴 In this session, we will dive into chromium’s huge codebase that we have no prior knowledge of. We will see how we can leverage our developers' instincts and AI skills to locate features and bugs in open-source projects. We will see how we can use skills, agents, and efficient context when we explore codebases while avoiding burning through millions of tokens

Omri Bar-Zik

Secure Mobile App Development in React Native - Think Like a Hacker

Think HTTPS makes you safe? Think again. From poisoned dependencies to deep‑link traps, we’ll peel back the layers of a React Native stack and reveal the places attackers love to hide - plus quick wins to shut them out.

Yonatan Bergman

Context Diet

Scale LLM tasks to thousands of items without a giant prompt! Generative AI can feel like magic: you hand the model everything it might need and let it do its thing. It works, until the number of items grows, and every call gets slower and more expensive. There is a subtler catch: too many similar items make the model's responses inconsistent, even before the context length becomes a concern - and we have the numbers to prove it. At a few thousand items, "hand it everything" becomes less attractive as an option. This talk describes a comparative experiment ran by our team at Ai2 on 3 LLM tasks requiring scale-up to thousands of items. We will discuss techniques to reduce the number of items required to be in context while preserving quality: diverse sampling, incremental labeling, and clustered context. We will also look at how to evaluate such cases when no golden labels are available. Each technique is accompanied with experiment results for a real use-case.

Guy Wiener

From a Single Skill to a Sea of Skills: Architecting LLM Agents in Production

Have you written an LLM skill? It starts simple: define its goal, give it a tool, and it works. But what happens when you drop that isolated skill into a live system with hundreds of capabilities? At Wix, handling 300K monthly conversations, the challenge isn't just writing a skill—it's finding the right one in a sea of options. In this session, we’ll explore the lifecycle of production LLM skills. First, we’ll define what should actually be a skill and where they commonly crash in the wild (e.g., missing exit points, outdated context). Then, we’ll dive into the routing dilemma: When you have hundreds of actions, how do you trigger the exact right one? Do you retrieve them via RAG? Shove them all into the context window? Or filter them using deterministic code? Join us to compare these architectural approaches and learn how to scale autonomous agents effectively.

Ortal Ashkenazi

In AI We Trust? Summarizing Hotel Reviews at Booking.com

While AI enthusiasts were publishing blog posts, demos, and browser extensions showing how easy it is to summarize hotel reviews with LLMs, we were busy tackling the much harder challenge of building a feature that actually helps travelers. Building an AI-powered review summarizer is no longer the hard part. Building one that works consistently across nearly 4 million properties and hundreds of millions of reviews, while measurably helping travelers make better booking decisions, is. Join me to learn about our two-year journey of experimenting with prompts, models, data sources, evaluation methods, and UX at Booking.com. We’ll explore why offline AI metrics are only the beginning, why A/B tests often tell a very different story, and the surprising lessons we learned when real traveler behavior challenged our assumptions.

Manor Malchi Betzer

"Forward to Shraga!" — Training a Small Agent to Handle 1M Production Logs a Day

In Ramzor, Hefer survives a high-tech job with zero technical skills using one move: forward everything to Shraga. It works beautifully until Shraga relocates to Silicon Valley and Hefer quits, because the whole system was Shraga. Most teams shipping AI features today are Hefer: every request gets forwarded to a big commercial model, and it works right up until latency, cost, privacy, or a deprecation notice takes Shraga away. This talk is about building your own Shraga — a small model fine-tuned into a capable agent for one specific job. We built an agent that reads IT logs, diagnoses failures, and proposes verified fixes. We’ll take it from a vanilla small model that fails almost on everything to one that holds its own. We'll walk through what it took to get there, while tackling two questions that should come before any training: do we even need an agent for every task? and if so — how do we actually evaluate one?

Moran Mizrahi

Avinoam Bitton

Minicloud: a High-Fidelity Multi-Cloud Simulator

Cloud-native applications mean cloud-native testing, and at the end of each month, cloud-native billing for this testing. We present minicloud, a high-fidelity cloud simulator that simulates cloud APIs on your laptop. It is able to launch VMs using real AMIs (which it will auto-download). High fidelity means that great effort was taken so the application will be have exactly as it does on the cloud. Currently AWS and GCP emulation are supported. The project is written in Rust.

Avi Kivity

Edut 710's Living Archive of the Present. How to Build an Archive of an Event in Real Time.

Two days after October 7, before the scale of the disaster was known, dozens of volunteers began recording survivors' testimonies on film. Edut 710 grew out of that effort: a living archive of the present, built in real time with no institutional backing and no budget. Three years on, the archive holds more than 2,000 video testimonies and a RAG-based search agent that answers natural-language questions and points to the exact moments that support each answer. We will show how we designed the infrastructure: a testimony-person-place knowledge model with a unique identifier for every entity; witness consent encoded in the schema itself; field-level permissions that keep survivors in control of their own stories. The talk explores what happens when the humanities and engineering meet under emergency conditions, and argues that modeling knowledge is an ethical practice as much as a technical one, because it determines whether the archive manages to keep its historical and moral context.

Renana Keydar

Yael Netzer

Keynote

A Cellist's Path: Three Bets on the Space Between Fields

I believe the most interesting problems live between fields, not inside one. As a cellist, I became convinced music and the brain deserved to be one connected field. That belief led me through a PhD, into a neurotech startup betting the same insight could become real technology, and into a team decision to record EEG far beyond standard resolution, on a hunch there was more signal in the data than anyone had proven. Each bet took years: a real field, a real clinical product, and now AI surfacing patterns in a decade of data once dismissed as noise. I will close by playing live cello while my own brain response streams on screen. As AI takes over more technical execution, what becomes rare is you, whatever odd mixture of passions you carry alongside your engineering work. Stick with that other thing long enough to be good at it, and this is the moment to let it merge into what you build. There is room now for the weirdest combinations, mine included.

Neta Maimon, PhD

TrialFinder: From Personal Loss to a Search Engine for Hope

When someone you love gets sick, one of the first things you do is search for options. I found myself doing exactly that when my father was facing a serious illness, and quickly discovered that finding clinical trials is a broken process: outdated interfaces, unreadable medical jargon, and thousands of irrelevant results. Years of manually helping patients navigate this maze led me to build TrialFinder, a free, non-profit platform that matches patients with relevant clinical trials: from smart profile-based search and plain-language explanations, through eligibility checks and guidance on speaking with your doctor, to contacting the trial team. This talk covers my journey: how I designed an AI system that handles sensitive medical data without ever storing it, the early viral moment that stress-tested everything, feedback from patients and doctors, and emerging partnerships with hospitals and health funds. This is a story about building a zero-budget tool with nothing but purpose.

Daniel Korn

How We Merged Outbrain’s and Teads’ Clouds Without Starting a Holy War

Two companies merged. So did their clouds — and their cultures. One company grew up cloud-native: spot instances, managed-everything, move fast and trust the provider. The other spent a decade running its own Data Centers — reserved capacity, predictability, and a deep suspicion of anyone's markup. Then the orgs became one company, and suddenly there was a single cloud bill. On my desk. This is the story of how eng, organisations, systems, culture and tech stack (and tech debt) collapse into a single decision. How a commercial selection process can be warped and skewed in different angles and how the winner is not necessarily the cheapest. A war story about leverage, trust, and the investment in abstraction — told from the seat where the contract, the architecture, and the politics all land at once.

Shahar Barak

The Agent Acts, The Owner Sleeps: Trust and Control For an Always-On AI Agent

An AI agent that runs the admin for a small business keeps working after the owner goes to sleep. It messages clients, books meetings and follows up, and some of that should never happen without her. Which actions should wait for her? What does the agent do while they wait? And when she replies in the morning, how do you know what she said yes to? The talk answers all three, and shows how trust builds up until she doesn't have to be asked about the same thing every night. You'll leave with a way to decide which actions your agent can take alone, and practical advice on implementing it in a way that fits your use case.

Jenia Barabanov

Expired Truths: Engineering Advice That Stopped Being True

We're engineers. We measure, we benchmark, we run postmortems. We pride ourselves on not taking things on faith. So why do we quote advice we've never traced to its source? Why do we copy architectures off conference talks, and pass "best practices" down to juniors without ever asking where they came from? Here's the uncomfortable part: most of the advice we repeat was genuinely true once — in a specific context that has quietly expired. The conclusion survived; the reasoning didn't. We inherited the answer without the question. This talk traces a handful of beliefs we all hold back to the moment they were actually true, watches that moment disappear, and asks what we should do instead. It starts somewhere you won't expect, and ends with a single question that protects you from the next expired truth — including the ones you're teaching right now.

Nadav Beker

Ask the Genie for More Wishes 🧞‍♂️: When AI Can’t Keep Up with Real-Time Cyber Security

A simple employee at a cyber security company in Agrabah finds a lamp. The genie inside (a Large Language Genie) promises to solve his impossible job: stopping sensitive data from leaking (DLP) as users paste text, drag files and send emails across dozens of apps, each behaving differently, with verdicts due in milliseconds. But each wish is slow, expensive, and the genie gossips. So he finds the loophole, the one wish every genie forbids: wishing for more wishes. How do you get a genie’s full power on every endpoint without ever rubbing the lamp in production? A whole new world awaits in this session: solving a security agent’s hardest problems with AI.

Elai Eckhaus

4+3 Strategies to Boost Your Caches

Caching is a cornerstone of application performance, but are we truly leveraging its full potential? With increasing complexity in modern systems, selecting and adapting the right caching strategies can make or break user experience. In this talk, we’ll dive deep into the caching strategies we use at Teads to optimize performance, scalability, and reliability. You’ll learn the pros and cons of the different strategies, and discover how to combine them for maximum efficiency. By exposing real-world challenges, successes, and lessons learned, this session provides actionable insights to help you get the most out of your caching infrastructure.

Yonatan Zusman

Where's My Context? (Switched.)

I know multitasking is basically screwing up several things at the same time. And yet, since AI became part of my daily work, I find myself doing exactly that - filling every available moment with something else. AI creates gaps while we wait, and a FOMO to fill every gap with another thread. At some point, doing just one thing starts to feel wasteful. Almost useless. But what happens to our context when we work like this? Are we still close enough to the details to make good decisions that move us in the right direction? What do we still need to understand deeply, and what can we safely let go of? In this talk, I’ll revisit deep work in the age of AI: which principles still matter, which are no longer relevant, and which new habits we need now. And most importantly: can we get the leverage of AI without giving up the depth - and the feeling of being truly inside what we’re doing?

Shikma Lerer

Sleep Tight, the Agent’s On-Call: Autonomous Ops in the Real World

Who’s watching your production system at 2 a.m.? For us, it’s an autonomous AI agent. At UVeye, we scan over 3 million vehicle scans monthly across a global fleet of visual-inspection sites. When a camera drifts, a lane stalls, or image quality degrades, system blindness costs customer trust. Static alert rules simply couldn't keep up with physical-world telemetry and visual quality. In this talk, I’ll share how we put an LLM agent on-call. Instead of managing fragile alert rules, we built an agentic system where existing detectors act as dynamic tools. We’ll open up the hood to show the architecture: how the agent independently investigates root causes across logs, metrics, and storage. Finally, we'll walk through a real production catch, detail tool structuring, and tackle the hardest challenge - building enough system trust for engineering teams to act on autonomous findings.

Shira Navot

Six Months Living with a Personal Agent: What Works, What Broke, What I Learned

Six months ago I stopped playing with AI agents and started living with one. It runs 24/7, has persistent memory, sub-agents for dedicated roles, integrations with Gmail, Calendar, docs, and 15+ capabilities. Most of the time it works. Sometimes it breaks in ways I didn't expect. This talk covers the architecture that emerged, three concrete failures (including one where the agent replied on my behalf about a sensitive matter), the four principles that came out of the mistakes, and one rule that guards against most problems. Not a "how to build an agent" talk. A "what happens when you actually live with one" talk.

Dvir Arad

Inside the Black Box of an Engineering Journey: How Hidden Mechanisms Shape Career Opportunities

Engineering organizations are built on the promise of meritocracy: that good work speaks for itself. Often it does not. Long before anyone talks about promotion, visible and hidden mechanisms shape who gets the work that builds a career, whose contribution is credited, and who is considered for the next opportunity. Drawing on my PhD research and two decades in engineering and R&D leadership, this talk opens the black box of an engineering journey. We will explore how seemingly neutral practices shape careers over time, and how talent can remain unseen or underused. You will leave with a practical framework for recognizing these mechanisms around you and identifying where you can act to open real career opportunities.

Tsaela Pinto-Harel

From Black To White

From BlackHat to WhiteHat is a technical and personal journey from breaking systems out of curiosity, ego, and adrenaline, to using the same mindset to protect companies, products, and users. Through real stories from early tinkering, Android rooting, mobile security, RFID hacking, zero-day research, and security advisory work, I will share what changed, what stayed the same, and what I learned about ethics, responsibility, risk, and trust. This is not a morality lecture and not a "how to hack" tutorial. It is an honest look at how offensive knowledge can become defensive value.

Elia Yehuda

Your Agent Failed. You Blamed The Model. You Were Wrong.

Every team does the same thing. Agent behaves weirdly in production - retries endlessly, drops tasks, returns confident nonsense. First reaction: swap the model, tweak the prompt. It's never the model. Multi-agent systems aren't an AI problem. They're a distributed systems problem with an AI layer on top. And most teams skip all the boring infra - state management, observability, failure handling, routing - and pay for it later. We'll go through 8 agentic patterns (supervisor/worker, swarm, reflection, human-in-the-loop and more), and for each one: what the pattern does, where it breaks, and what infra you actually need before shipping it to production.

Daniel Ostrovsky

Duck Debugging Deadlocked Humans: A Practical Guide to Getting Unstuck

You’re stuck. You’ve tried everything. You’re circling the same dead end. You've considered abandoning tech to become a goat herder in the Alps. Now what? This talk is a fast, focused guide to what actually works when you hit a wall. Spoiler: it’s not more brute force. I’ll share a practical mental model for switching from Execution Mode to Exploration Mode, with concrete tools to diagnose your stuckness, tighten your feedback loop, and make real progress—whether you’re debugging a tough problem, facing a hard decision, or spiraling in self-doubt. *** No ducks were hurt during the making of this talk.

Lea Cohen Tannoudji

Hiring Post-Claude

The rise of AI tools like Claude hasn’t just changed our daily git commits—it has completely rewritten the playbook for what makes a great developer and how we build engineering teams. In this fast-paced, 5-minute talk, we will contrast what we used to look for in candidates versus the skills we prioritize now in an AI-driven landscape. We will bust the industry myth that junior engineers are obsolete, and instead explore how their personal growth and onboarding look vastly different today. Finally, you'll get a direct look inside Wix, sharing our internal approach to cultivating the "xEngineer" and how we are actively restructuring our programs to turn entry-level talent into AI-native powerhouses

Guy Nahum

How to Cheat at Hebrew Codenames (Without an LLM)

Codenames: the spymaster gives one clue word and a number, and the team guesses their cards without hitting the assassin. In an era when we bolt an LLM onto everything, I wanted to see how far classic tools and a little local geometry could go, so I built a Hebrew Codenames copilot that gives better clues than I do. Word vectors, some geometry, zero large language models. The idea: words are vectors. A good clue is the point closest to your cards and farthest from everyone else's, with a heavy penalty for drifting toward the assassin. Along the way, a small static model (fastText) gave stronger, safer clues than a 12B Hebrew LLM, a reminder that this task rewards a clean vocabulary and careful handling of risk more than raw scale. I'll show what worked, why Hebrew makes it genuinely harder, and where the simple approach breaks and how to fix it. No heavy math, and there's a live demo you can try.

Shmulik Cohen

Are Quantum Computers Faster?

"Quantum computers (QCs) are faster because they try all options in parallel", we've all heard that trope at some point, but is it any true? This session aims to bust a few very common quantum myths that are widely spread in science journalism and social media. We will address 3 myths that are intertwined: (a) QCs are “faster”, (b) QCs try all possible paths in superposition, and (c) QCs will solve every hard problem from climate change to optimization. This lightning session will not include any math, or “intro to QC”. It aims to leave the audience a bit less clueless about this exciting paradigm.

Iftach Yakar

Your Agent Doesn't Know You

Agent memory got better this year. Awareness of the human is still unsolved. Your Claude Code doesn't know you slept four hours and need to take it slow this morning. Your OpenClaw doesn't know you skipped your run and you're already restless by 10am. So they answer the same way whether you're sharp or fried, and interrupt the same way whether you're deep in flow or staring at the ceiling. In 5 minutes, we’ll introduce the Inner World Model, the missing layer in the agent stack. We’ll cover how to integrate the Inner World Model as an EQ layer of an ai agent, and show a quick demo of what it's like to work with an agent that knows you.

Limor Lahiani

Omri Mendels

Hear No Evil: When AI Guardrails Can't Hear the Threat

Sound is just a wave - and a wave has parameters you can bend: pitch, frequency, amplitude. All it takes is open-source tools and a laptop. Turns out, something unsettling happens: an AI model will refuse a request in text, then comply with the exact same request when it arrives as sound. In 5 rapid-fire minutes, I'll walk through adversarial audio attacks on multimodal AI - the same instruction, reshaped acoustically, sliding past the model's defenses without changing a single word. You'll see how a shifted frequency confuses a multilingual model, a trimmed waveform slips past prompt-injection detection, and a modulated carrier wave evades transcript-based filters - all without touching the text itself. Pitch, frequency, amplitude: the same tools a sound engineer uses to master a podcast are the tools an attacker uses to jailbreak an AI.

Tsofit Zazon

שיר - יוני ויפתח נפרדים

הגיע הזמן להיפרד 😢 להאזנה לשירים משנים קודמות: https://youtube.com/playlist?list=PLvv1VJsbJ2I62N7VmIy_PcEU9wFmEOVTi&si=duBIRWxO9v0Y4hnq

Yoni Tsafir

Iftach Bar

What Game Are You Playing?

Every game has a winning strategy, and it's never written in the rulebook - it emerges from the rules. Change a rule, and a different strategy wins. The same is true of everything we build: products, KPIs, team processes. Each choice quietly makes some behavior the winning move, whether we intended it or not. In this session we'll reverse-engineer everyday apps, working backward from visible behavior to the rule behind it. Why is X the meanest room on the internet while Reddit stays surprisingly honest? Why does everyone sound fake on LinkedIn? Why can you trust an Airbnb review but not an Amazon one - when it's often the same people? Then we'll turn the lens on our own work: retention problems, teams that play it too safe, KPIs that reward exactly the wrong thing. You'll leave with a new reflex: when behavior surprises you, stop blaming the players - find the rule that made winning look like that.

Ifat Koller

Logs For The AI Era: Observability When Humans Are No Longer The Only Readers

We are adding AI to our workflows, our IDEs, our incident response, and sometimes even our production investigation process. But AI does not see production truth. It sees the signals we give it: logs, metrics, traces, code, dashboards, and runbooks. In this talk, I’ll share a real production story where a feature looked available, the deployment was green, and logs existed — but the feature delivered no value. When we gave the available signals to AI, it produced a confident but wrong direction. We’ll use this story to rethink observability for the AI era: not as “more logs,” but as a way to reduce ambiguity, expose hidden domain context, and help both humans and AI tools reach better hypotheses faster.

Melanie Shoresh

Escaping the "Double-Token Tax": Scalable LLM Analytics for Conversational Agents

Running conversational agents in production is expensive, but analyzing their unstructured logs at scale using LLMs introduces a painful "double-token tax" - burning budget during the conversation, and again during analysis. This session introduces a database-native design pattern to escape this tax and scale conversational LLM analytics to millions of interactions at a fraction of the cost. We present a two-part architecture: - Insights Surfacing: Automating category distributions and user intent mapping utilizing unsupervised clustering and drift-aware LLM labeling. - Interactive Semantic Discovery: An interactive natural-language agentic interface enabling ad-hoc semantic queries directly on the data warehouse, analyzing millions of conversations at scale with high quality by combining LLMs and light ML models. By bridging these modes, teams can extract latent user needs hidden in massive log volumes and turn raw dialogues into actionable product improvements.

Haim Cohen

What Couples Therapy Taught Me About Working With AI Agents

I work at a company that builds a couples-therapy platform. So when I found myself fighting with my agent again, it hit me: what if I applied the principles we teach couples to this relationship? Because here is what was happening. I would curse at it, it would over-explain itself, I was convinced it was an idiot, and its answers fed my anger. I was treating it like a junior who could not keep up - reviewing every line, shipping one PR a day. So I brought it to our clinical team, who do this with real couples daily, and together we translated it into daily work with an agent: sit down after a fight, look at the cycle instead of the incident, have each side own its part. What came out of that, technically: a mechanism that lets the agent admit it is stuck without halting the process, and an explicit agreement on how uncertainty gets disclosed instead of bluffed. From 1 PR a day to 3-4. You will leave with tools for working with your agents, and maybe with your actual partner too.

Eyal Abbas

Autoscaling: Cost Optimization Turned Reliability Nightmare

Autoscaling gets slapped onto nearly every deployment, and the usual results are surprise bills and cascading failures. Here's the uncomfortable part: autoscaling isn't a scaling solution at all — it's a cost optimization. You still have to design and test for peak load yourself. Worse, the moment you enable it you've adopted a feedback control system — with dead time, gain, and coupling to your load balancer — and almost nobody treats it as one. This talk is about what autoscaling actually is, why "just turn on the HPA" produces oscillation and outage amplification, and what responsible use looks like: design for max scale first, keep the scaling units well-behaved, protect upstream resources, and pick your control loop on purpose.

Avishai Ish-Shalom