[Talk::Overflow #21] AI Engineer Paris 2025

Welcome to the 21st edition of Talk::Overflow!! This week, we are covering the talks from the AI Engineer Conference in Paris.

MCP is a classic “looks small until you run it in production” protocol, and this talk is framed exactly that way. Woodward’s focus is on what it takes to build something that can scale and evolve at community speed without letting security drift. The real engineering lesson is that you’re shipping a product in an ecosystem: you need versioning and backward compatibility as non-negotiables, not “we’ll add it later.” He also highlights that you can’t treat the server as a friendly internal tool—design for untrusted clients and bake in rate limiting from day one. The throughline is security as an operational posture, not a checklist.

Leger’s claim is that the GPU gold rush phase is over; what comes next is agentic workflows that force more diverse, resilient systems design. Instead of treating “agents” as an application detail, he frames the requirements as infrastructure primitives: secure sandboxing, continuous inference at scale, and predictable performance across heterogeneous compute. The helpful mental model is “chips → virtualization → storage,” because a flaky runtime or a brittle state layer will dominate your user experience long before prompt tweaks do. This pushes you toward treating inference like a real service with SLOs and incident response. In practice, it’s a call to invest in the boring foundations: storage and isolation.

The provocation is simple: humans don’t freeze behavior, so why should system prompts be static? Dhinakaran describes a post-deploy learning loop where natural-language feedback becomes an error signal and a MetaPrompt rewrites targeted instructions. The key shift is moving prompt changes from “manual craftsmanship” to something more like continuous improvement for agents. Once you do that, the hard part becomes governance: you need guardrails, rollout/rollback, and measurement so self-modification doesn’t become self-sabotage. The talk makes the case that evaluation is the glue that keeps this loop honest.

This is a performance-first talk about making context cheaper by changing the attention algorithm itself. Morin presents sparse attention that runs in log-linear time, aiming to reduce compute while keeping output quality. The surprising target is the CPU (over UDP), with the claim that this can match or beat GPUs in certain scenarios—less “GPUs are bad,” more “architecture changes what’s optimal.” If your product economics are dominated by context length, this is an explicit attempt to bend that compute cost curve. The broader takeaway is that attention doesn’t have to be a fixed tax; it’s an optimization surface.

Voice agents are where “model quality” hits physics: latency and turn-taking aren’t optional features. Zeghidour describes Kyutai’s real-time voice work as a progression across full-duplex conversation, speech-to-speech translation, and customizable voice agents. The practical point is that the voice stack is a systems stack: streaming, synchronization, and failure handling are as important as the model. In other words, getting to usable UX is an engineering problem, not just a model problem. If you’re building voice, prioritize robustness early—users will notice the glitches before they notice your benchmark scores.

This keynote makes an enterprise case for open source AI: not ideology, but leverage. Lavaud frames adoption blockers as practical constraints—vendor lock-in, data complexity, and opaque systems that fail the “explain it to compliance” test. Open models, in this framing, are about regaining transparency and control so you can integrate AI into existing systems on your terms. The payoff is that you can tailor deployments for your environment instead of bending your architecture to a hosted API. If you’re doing regulated or high-stakes work, this is essentially an argument for customization as a prerequisite for reliability.

Eifrem’s framing is that AI apps aren’t “just prompts”—they’re systems that manage state across memory, tools, and workflows. From a knowledge representation lens, he looks at what “state management” patterns are emerging in the wild. The point is less about any single database and more about the data layer becoming the architecture once you introduce agents and long-running tasks. He grounds this in observed deployments across startups and enterprises, which is where the advice gets practical. If you want your app to be debuggable and evaluable, invest early in the primitives that make those patterns explicit.

Blattmann argues that image generation is impressive, but editing is where products actually get judged. Iterative editing tends to trade off speed vs consistency, and that’s a UX killer when users make multiple passes. The talk explains how FLUX.1 Kontext aims to solve this using Latent Flow Matching for consistent iterative edits and diffusion distillation techniques for near real-time inference. The meta-lesson is that interactive workloads force you to optimize for iteration loops, not single-shot hero outputs. If you’re building creative tools, treat distillation and consistency as product features, not research curiosities.

Sifre’s thesis is that the next wave of AI is built from open source “bricks,” not closed monoliths. The point isn’t just efficiency; it’s that developers need freedom to combine and extend building blocks to move fast. That pushes toward composability as an ecosystem principle: tools are valuable if they plug together cleanly. He also calls out the practical pain that follows from a fragmented ecosystem—discoverability becomes work—hence the idea of a portal to find/test/assemble components. The takeaway for builders is that “open” only compounds if the integration path supports fast iteration.

This live session is framed as “data generation is like code generation,” joys and tribulations included. The implicit lesson is that synthetic data isn’t magic: you still have to worry about correctness and coverage. If you don’t measure, you just generate bias faster, which is worse than being slow. The healthy model is to use generation to accelerate iteration, then close the loop with real checks. If you’re doing fine-tuning or evals, treat validation and distribution matching as first-class work, not cleanup.

Srivastav frames this as a pragmatic check-in on open LLMs: what’s shipping, what’s being adopted, and what constraints shape the space. The talk explicitly calls out the friction points—scaling and regulation—that determine whether “open” is viable for your use case. The value is calibration: where open models are thriving vs where you should expect pain. If you’re deciding between closed and open, this is a way to reason about ecosystem maturity and adoption patterns. It’s also a reminder to include roadmap risk in your architecture decisions, not just today’s benchmark.

Çelik starts from a familiar reality: basic RAG is easy; production systems demand multi-step reasoning plus tooling and control. The talk demonstrates agent workflows using an event-driven architecture (LlamaIndex Workflows 1.0), emphasizing query planning, memory persistence, and state management. NotebookLlama is used as the concrete example, which is useful because it forces the design to handle real workflow constraints (analysis, generation, validation) instead of toy prompts. The practical point is that workflow boundaries can reduce error by constraining behavior and making execution observable. If you’ve struggled with agents “going off script,” this is a blueprint for getting that back under control via tool use and explicit orchestration.

Bailey frames this as a tour of what’s changing in generative AI beyond “better chatbots,” centered on hands-on demos. The abstract highlights multimodal creation capabilities (including video) and stronger reasoning, plus tooling via AI Studio. A key signal is the emphasis on on-device performance (via open models) as a product enabler, not just a deployment detail. If this wave lands, teams will ship more interactive creation features—and that quickly turns into pipeline engineering where budgets and UX constraints dominate. The practical reminder is to treat latency and user control as part of the design spec from the start, not as a post-demo optimization.

You’re reading [Talk::Overflow #21] AI Engineer Paris 2025 Tech Talks — the weekly digest for developers who want to stay sharp and skip the noise.
→ Browse past issues
→ Suggest a talk
→ Share it with the friends

Stay curious. Stay kind.

— Talk::Overflow