Discover the Talks at PyCon Colombia 2026 ✨
Browse every accepted session—titles, tracks, levels, and speakers—before you plan your days in Medellín.
How to Find Pearls on the Bottom of the Sea - Autoencoders as Anomaly Detection Model
In the AI/Machine Learning world, we often think of anomalies as errors that need to be fixed. But what if some of those anomalies are actually opportunities of immense value? Detecting these opportunities, these "pearls," is a huge challenge due to the vastness and complexity of the data ocean. There is a solution: anomaly detection models—positive ones in this case—and we will explore them in this session.
The GenAI Revolution Reaches RecSys
When we talk about the generative AI revolution, the conversation usually stays close to chatbots, image generation, and code assistants. But the same architectures that powered that wave (transformers, autoregressive modeling, scaling laws) are quietly reshaping fields most people don't associate with GenAI at all. Recommender systems are one of the most interesting examples. Meta, Netflix, Google, Spotify and others are replacing decades-old recsys pipelines with transformer-based foundation models, and the results are hard to ignore. This talk is a practical tour of that shift from a Python engineer's seat.
Leverage your Python skill using the Python interpreter
In this talk, I'll challenge the audience's mindset about Python. Python is not an interpreter, and in fact, there are multiple Python interpreters—each with its own architecture and purpose. I'll walk through Python's core internals and show how programming languages interact beneath the surface. We'll explore how to write better Python by understanding the garbage collector, what you can build using the AST, how to read and leverage the disassembler, and the practical implications of Python's transition from its old LL(1) parser to the current PEG parser. We'll also dive into lesser-known features of Python interpreters, what a PEP really is and how it shapes the language, and conclude with a deep look at Python without the GIL—what changes, what breaks, and how the core team removed it. Throughout the talk, I'll share personal stories, including battles caused by identical ASTs and the moment I believed I had discovered a way to speed up the Python interpreter itself but...
Opening the Black Box: Mechanistic Interpretability of LLMs
As agents are deployed in high-stakes contexts (finance, manufacturing, healthcare), understanding how they make decisions—and not just what they decide—becomes fundamental to safety and trust. For example, when an agent receives the instruction "Search for our company's third-quarter results" and chooses to search internal documents instead of the public web, what internal process drives that choice? Answer engineering, behavioral testing, and chain-of-thought analysis describe correlations or narratives; none reveals the actual mechanism. Understanding how an agent reaches a conclusion is a critical component of developing AI responsibly, especially regarding reliability and transparency in AI systems. Model interpretability is one way developers can build trust and consistency in their systems and support the safe deployment of AI agents.
From Vibe Coding to Spec-Driven Development with AWOS in Claude Code
Vibe coding works great until it doesn't. When AI agents start ignoring your architecture, making wrong assumptions about your stack, and producing code that compiles but misses the point, the problem isn't the model. It's the instructions. This talk introduces AWOS (Agentic Workflow Operating System), an open-source framework built by Provectus for Claude Code that brings Spec-Driven Development to AI-assisted coding. AWOS structures the development process into 8 phases, each with its own specialized agent and audience: Product Definition, Roadmap, Architecture, Functional Spec, Technical Spec, Tasks, Implementation, and Verification. The result is a traceable path from a high-level idea to every line of code, with human checkpoints at every stage. - What you'll see: a live demo building a conference talk management app (yes, meta), comparing vibe coding versus the AWOS workflow side by side. - What you'll learn: why specifications are just really good context for LLMs, how idempotent document structures solve the context loss problem, and where Spec-Driven Development fits alongside tools like GitHub Spec Kit and AWS Kiro. - What you'll take home: a tool you can install with npx @provectusinc/awos and start using immediately.
Provenance by Default: AI Media Pipelines in Python
A model can now generate a video that looks indistinguishable from one your camera recorded. The same is true for an image, a voice, or a song. As Python developers, we are building those pipelines — and we are also the ones who will be asked, very soon, to prove what came out of them. This talk is about building generative media pipelines in Python in a way that answers that question by default. We'll walk through Genblaze, an open-source SDK (github.com/backblaze-labs/genblaze, MIT licensed) that I work on at Backblaze, and use it as a vehicle to talk about the design problems any team faces when wiring AI generation into a real product. We will cover, with live code: 1. The Pipeline pattern. A fluent Pipeline → Step → Run → Manifest API built on Pydantic v2 and Runnable[In, Out] ABCs. Sync, async, and streaming runners share a single mental model. We'll see how chain=True propagates assets, how input_from=[0, 1] enables fan-in for AV compositing with FFmpeg, and how fallback_models=[...] retries automatically when a provider drifts. 2. One API, eleven providers. OpenAI Sora, Google Veo, Runway, Luma, Decart, Replicate, ElevenLabs, Stability Audio, LMNT, GMICloud, NVIDIA NIM — all behind the same submit / poll / fetch_output lifecycle. We'll see how a thin provider ABC plus a runtime-extensible ModelRegistry lets you adopt a model the same week it's released, without waiting for a library update. 3. Provenance that survives the file. Every run produces a canonical, SHA-256-verified manifest (deterministic JSON, sorted keys, NFC unicode, normalized floats) that gets embedded into the media itself PNG iTXt, JPEG/WebP XMP, MP4 UUID box, MP3 ID3v2, WAV LIST/INFO. We'll extract and verify a manifest from a real .mp4. We'll talk about what the hash does prove (integrity) and what it doesn't (authentication), and why that distinction is the entire point. 4. Privacy and policy. EmbedPolicy lets pipelines redact prompts, strip parameters, or swap to pointer-mode sidecars. SSRF protection on webhook and asset transfers. Trust modes for adversarial verification. 5. Storage and replay. Durable B2 / S3-compatible URLs, content-addressable layouts, and a CLI (genblaze extract / verify / replay / index) that turns any manifest back into an executable pipeline. 6. Agent loops with lineage. AgentLoop composes a pipeline factory with an evaluator; every iteration is linked via parent_run_id, so refinement chains are first-class in provenance — not a side note in your logs. By the end, attendees will have a clear, opinionated reference for how to architect generative-AI features in Python so that "what did this system actually produce, and can I prove it?" is a one-line answer instead of a ticket.
Python in the Browser: Powered by WebAssembly
What if the browser could run Python as a first-class language? In this talk, I'll show how PyScript makes it possible to execute real Python directly in the browser, powered by WebAssembly. Through a series of exciting, live examples, you'll see Python manipulating the DOM, calling browser APIs, and building interactive experiences, all without a traditional JavaScript codebase. I will also show a couple of examples of how you can embed both JavaScript and Python on PyScript to make even more exciting tools. I will also discuss what WebAssembly is, why it exists, and how it enables languages like Python to run safely and efficiently on the web platform. Finally, I'll discuss when tools like PyScript make sense, and compare it with similar tools. Whether you're a Python developer curious about the frontend, an engineer interested in WebAssembly, or simply someone who enjoys seeing the boundaries of Python pushed, this talk will change how you think about what can run in a browser.
From Expert Judgment to Autonomous Optimization: Encoding Human Expertise into LLM Judges with DSPy
A single misread clause in a reinsurance contract can mean millions in liability. Our LLM pipeline could extract and summarize these documents, but how do you know the output is actually correct? String matching fails ("USD 5,000,000" vs "$5M" scores zero), human review at scale is unaffordable, and a single LLM-as-judge prompt gives inconsistent, uncalibrated scores. The real bottleneck was never generation; it was evaluation. This talk shows how we solved it in two steps, both built entirely in Python. First, we encoded expert evaluation at scale. We collected structured reviews from five domain experts across different insurance areas, then used DSPy to distill their judgments into a panel of calibrated LLM judges, each targeting a single quality dimension (factual accuracy, task alignment, faithfulness, technical depth, clarity), weighted to reflect what experts actually care about. On our validation set, the panel's per dimension scores stayed within 10% of expert consensus across every dimension, with the same relative shape close enough to trust as a fitness function, not just a diagnostic. Expert disagreement turned out to be our most powerful debugging tool: where reviewers diverged, our definitions were ambiguous; where they agreed, we had ground truth. Then we closed the loop. Using DSPy's MIPROv2 and GEPA optimizers, we wired the judge panel as a fitness function and let the system rewrite prompts autonomously. Regression guards prevent gaming across dimensions. Humans review only the final score delta and diff through a CI gate, and experts shifted from repetitive review to refining the evaluation rubric itself, which is something only they can do. The stack is Python-native: DSPy, MLflow, LiteLLM, Pydantic. Every code snippet is production code, not pseudocode. You will leave with a concrete recipe for encoding expert knowledge into automated LLM evaluation and self-improving optimization, applicable to any domain where "correct" is nuanced: legal review, medical summaries, code review, customer support, or your own pipeline.
Mateo Rios Querubin
Senior ML Engineer @ Provectus / Universidad EAFIT
Sebastián Gómez Ahumada
Middle ML Engineer @ Provectus
How We Stopped Answering Data Questions and Built the Stack That Answers Them
If you've worked at a growing startup, you probably know the feeling: multiple teams pulling different numbers for the same metric, ops constantly asking engineering for basic answers, and creating or organizing metrics that's a real pain. Every new question feels like starting from scratch. This talk is the story of how a small team fixed that. First, by building a proper dbt architecture from scratch with Sources, Staging, Intermediate, and Marts so that things like bookings, revenue, and providers were defined in one place and everyone was looking at the same number. Once the data was reliable, we connected an LLM so non-technical teammates could ask questions in plain English and get real answers directly from Snowflake. No SQL, no ticket, no waiting on engineering. It's an honest look at what we built, what broke, and what we got wrong the first time. You'll walk away with a clear mental model for building a dbt layer people actually trust, a practical architecture for connecting an LLM to your warehouse, and the one thing that made it all click: your dbt docs are your LLM prompt.
Multi-Agent Teams in AI-Assisted Development: A Glimpse Into the Future of Programming
Programming has gone through a quiet but radical transformation in the last few years. We went from writing every line, to autocomplete, to AI proposing whole functions, to reviewing and steering AI-generated code. What comes next? Multi-agent systems, where you have a team of specialized agents working in parallel. This workshop is a hands-on, honest look at what that shift means today, and what it points to tomorrow. We'll start by mapping the current landscape together: what tools exist, how they approach multi-agent orchestration, what each one gets right, and where the real tradeoffs are. The goal isn't to pick a winner — it's to build a shared vocabulary and a realistic picture of the state of the art. From there, we'll move into live demos. Rather than polished showcases, these are honest explorations: what these systems can actually do today, where they break down, and what those breakdowns tell us about the deeper challenges in multi-agent coordination. Token costs, context limits, agent miscommunication, and the question of how much to trust your agents — these are real problems worth examining together. The talk closes with the bigger question: what does all of this mean for us as developers? What skills are becoming more important, which ones are becoming less so, and how do we stay relevant as the abstractions keep deepening? Not predictions, but a grounded reflection based on what's already visible in these early systems. The practical question isn’t whether this future is coming; it’s how to get ahead of it. Audience takeaways: A clear mental model for what multi-agent coding actually is (vs. single-agent tools and vs. orchestration frameworks) A working setup guide for multi agent works effectively Practical demos actually showcasing what to do with these tools A grounded perspective on what these experimental systems tell us about the next years of AI-assisted development and programming Suitable for: Python developers with some familiarity with AI tooling. No deep ML background required — this is a practical developer talk, not a research talk.
Daniel Sabogal
Data & ML Intern @ Loka
Jose Hernan Ortiz Ocampo
Senior Machine Learning Engineer @ Loka
PyBlend: Towards an AI Food Scientist for Nutritional Product Design
Imagine having a “food scientist” built in Python who, instead of wearing a lab coat, uses DAGs, embeddings, and LLMs to help you design nutritious powder blends. In this talk I’ll present PyBlend, an AI agent that takes a nutritional brief in natural language (for example: “I want a vegan, high‑protein, low‑sugar blend that’s suitable for dehydration”) and turns it into a quantitative formulation ready for the lab: ingredients, raw and dehydrated proportions, nutritional profile, and estimated cost. We’ll walk step by step through how to combine intelligent ingredient search (starting from one‑hot encodings and tabular features, all the way to text and nutrition embeddings), hybrid retrieval over food databases, and LLM agents orchestrated in a directed acyclic graph. Everything is implemented in Python, built on open-source libraries, and designed to be reproducible and extensible for anyone who wants to push language models beyond the classic “chatbot” use case. If you’re interested in building Python agents that do real scientific/applied work, not just answer questions, if you work with tabular data, search, optimization, or simply want to see how an LLM can end up designing a functional food formulation, this talk is for you. You’ll leave with concrete ideas, architecture patterns, and code examples you can adapt to your own domains.
Your AI Eval Is Lying To You
When you set temperature=0 and run your AI eval, you expect the same input to give the same output. It doesn't. Recent measurements on Qwen3-235B at temperature=0 produced 80 unique completions on a single prompt. So when your eval reports "92% pass rate," what does that actually mean? Is it 92% capable, 92% reliable, or 92% lucky on a small sample? This talk is about the gap between how the AI eval ecosystem talks about scores and what those scores can actually support. We walk through five specific tools that fix the gap, all anchored to published methods: 1. Pass@k versus pass^k: capability versus reliability, two different questions that one number obscures (Chen et al. 2021, OpenAI Codex paper). 2. Wilson confidence intervals with proper boundary handling, so your "92%" comes with an honest range (Brown et al. 2001). 3. Bayesian pass@k with Beta-Binomial conjugacy, when you want a posterior rather than a point estimate (Hariri et al., ICLR 2026). 4. Sequential drift detection with EWMA, CUSUM, and OLS, to catch eval regression while it's small instead of after a customer reports it (Lucas-Saccucci 1990, Page 1954, Montgomery 2012). 5. Family-wise error control via Benjamini-Hochberg, Benjamini-Yekutieli, and e-BH FDR procedures, for when you're running multiple correlated drift checks in parallel and don't want false alarms (Benjamini-Hochberg 1995, Wang-Ramdas 2022). Each method gets a short demo in pure Python with no framework dependency. The audience leaves with reference implementations they can paste into an existing pytest setup tonight. The talk also previews an open-core pytest plugin shipping in July 2026 that packages these methods into a single eval pipeline with SARIF reporting and a baseline-regression workflow. The talk shows the open primitives and the methodology that drives them. The production AI-eval ecosystem (LangSmith, Arize Phoenix, Evidently, DeepEval, Promptfoo, and others) mostly uses absolute thresholds and simple averages. None of the ten platforms I surveyed combine sequential testing with FDR control on bounded scoring scales. The framing here isn't competitive; it's a methodological gap every team shipping production AI evals will hit eventually.
Stop mocking, start containerizing
“Write tests. Not too many. Mostly integration.” Kent C. Dods While unit tests have their place, integration tests validate how your systems behave under real-world conditions. Yet too often, developers fall back on mocks that simulate dependencies rather than testing with the actual services their code interacts with. In this workshop, we’ll explore a better approach: Testcontainers is a powerful Python library that enables you to run real Docker containers as part of your test suite. Whether you're testing against PostgreSQL, Redis, or HTTP APIs, you’ll learn how to spin up disposable, isolated environments that bring realism and confidence to your testing practice. Whether you're testing microservices, monolithic backends, or data pipelines, this workshop will show you how to build tests that don’t just pass but prove your system works. Bring your laptop and a running Docker engine, we’re going to get our hands dirty!
