Sasha Denisov
Sasha is CTO at Brainform.ai with over 20 years of experience architecting scalable enterprise systems. With a strong engineering background, his expertise spans frontend, backend, cloud infrastructure, mobile development, and AI — from cloud-based generative AI to on-device solutions. He specializes in building robust, production-ready products using a variety of technologies and frameworks. Sasha has delivered solutions across fintech, digital media, and entertainment. He is a Google Developer Expert for Cloud, AI, Firebase, Flutter, and Dart, co-organizes the Flutter Berlin Community, and is a recognized international speaker and writer, having presented at 30+ conferences worldwide.
Sessions
flutter_gemma started as a thin wrapper over MediaPipe for running Google Gemma on Android and iOS. Today it's a full-fledged platform for on-device AI: 6 platforms (Android, iOS, Web, macOS, Windows, Linux), 2 inference engines, multimodal support, function calling for local agents, and on-device RAG with vector search. The plugin has been featured by Google AI for Developers.
In this talk, we'll walk through the evolution via key engineering decisions. How adding Web platform forced us to rethink file handling and led to sealed classes instead of string URLs. Why we had to spin up a gRPC server in Kotlin with a bundled JVM for desktop — and how to automate the build through Xcode build phases. How the Strategy pattern allowed us to add a second inference engine (LiteRT-LM) without rewriting existing code, and how the Adapter pattern helped reuse the MediaPipe implementation. Why we needed chunk buffering for engines with fundamentally different APIs.
We'll dive deep into on-device RAG: how to build a SQLite VectorStore that works identically on mobile and in the browser via WASM. I'll show real bugs and their fixes — from Web hot restart crashes to iOS Simulator limitations with vision models.
The latest addition is genkit_flutter_gemma — a bridge to Google's Genkit for Dart that enables hybrid AI pipelines. Now you can seamlessly combine on-device inference with cloud-based models in a single Genkit flow: run lightweight tasks locally for speed and privacy, and escalate complex reasoning to the cloud — all orchestrated through one unified pipeline.
Every architectural decision in flutter_gemma is an answer to a specific problem. Minimum theory, maximum code, diagrams, and stories of "how it broke and why it looks like this now".
Most applications treat AI as a cloud-only feature — send a request, wait for a response, pay per token. Open models like Gemma, Llama, DeepSeek, and Phi freed developers from proprietary APIs, but not from costs: you still need to host them somewhere — GPU servers, infrastructure, per-request pricing. You can run models directly on the user's device — zero inference costs, offline access, full data privacy. But there's a trade-off: models small enough to run on a phone or in a browser can't handle every task.
Hybrid AI is the answer to this dilemma. Combine cloud and on-device models in a single application: simple and privacy-sensitive tasks run on-device, complex reasoning and multimodal workloads go to the cloud. The problem is that you end up maintaining two completely different inference stacks: different runtimes (TFLite, LiteRT-LM, llama.cpp), different model formats (TFLite flatbuffers vs GGUF), different quantization strategies, and different streaming APIs — all within one app.
In this talk, I'll show how to solve this problem with Genkit — an open-source AI framework from Google with an open plugin system. Each plugin adapts a specific runtime or model format to a unified pipeline: genkit_flutter_gemma for TFLite/LiteRT models, genkit_llamadart for GGUF. Engine-specific details are hidden behind a single API for flows, structured output, tool calling, and agentic workflows. Need a new runtime? Write a plugin. New model format? Same story. On-device inference runs across Android, iOS, macOS, Windows, Linux, and Web — switching between cloud and local execution is a one-line model reference change.
We'll explore hybrid patterns in practice: how to route between on-device and cloud based on model capabilities, connectivity, and task complexity. We'll cover the real trade-offs — quantization impact on output quality, memory constraints across platforms, cold start latency, and when hybrid actually makes sense versus pure cloud or pure edge.
Open-source models made on-device AI possible. Open-source tooling makes hybrid AI extensible.
Most AI solutions in e-commerce today are still rule-based chatbots. The next step — intelligent assistants powered by RAG and function calling, capable of working with product catalogs and guiding buyers through purchases in a conversation — is gaining traction but remains far from mainstream adoption. And on the horizon, a third model is already taking shape: fully agentic commerce, where a buyer's AI agent independently discovers, compares, and purchases products without ever visiting a store's website.
What makes this shift possible is open source. The entire infrastructure for agentic commerce is being built on open standards and protocols licensed under Apache 2.0. First came universal protocols — Anthropic's MCP for agent-to-service interaction and Google's A2A for agent-to-agent communication. Then, specialized commerce protocols emerged on top of them: Google's UCP backed by Shopify, Stripe, Visa, and 20+ partners, and OpenAI's ACP co-developed with Stripe. All open source. All community-governed.
In this talk, we'll explore where the industry currently stands on this evolutionary ladder, how the approaches of key players differ, why they chose open source as the foundation for commercial infrastructure, which early experiments have already failed — and what sellers and developers should be doing today to prepare for a world where the storefront is a context window.