Discover the Talks at PyCon Colombia 2026 ✨
Browse every accepted session—titles, tracks, levels, and speakers—before you plan your days in Medellín.
Future-proof Engineers with AI-DLC
The Problem Today, many engineers have fallen into a trap: they are using Artificial Intelligence simply as a "glorified autocomplete" to write code faster, leaving architectural design aside. The real challenge arises in the real world: technical teams often do not know how to take an AI-based idea to production safely, scalably, and maintainably. The Solution: Future-proof Engineers with AI-DLC This is a practical, intensive workshop designed to break that stagnation. Our goal is for you to stop being a passive consumer of AI tools and become an architect capable of applying the AI Development Lifecycle (AI-DLC) as a structured work framework. We will teach you to take control and increase ownership in your projects. Who is it for? Mid and Senior software engineers looking to evolve their skills, master modern system design, and lead AI integration in their work teams.
Carlos Alberto Riveros Varela
Senior Software Engineer @ EPAM Systems
Jesús Alfredo Reyes Vargas
Lead Software Engineer @ EPAM Systems
Machine Learning Applied to Genetic Sequences
DNA contains massive amounts of biological information, but how can artificial intelligence help us understand it? In this talk, we will explore how Python and Machine Learning can be used to analyze genetic sequences in a practical and beginner-friendly way. Using public biological datasets, we will demonstrate how DNA sequences can be transformed into data suitable for machine learning models, covering concepts such as feature extraction, sequence representation, and basic classification techniques. We will also review popular Python tools used in bioinformatics, including Biopython, pandas, and scikit-learn, while discussing real-world challenges when working with biological data, such as high dimensionality, noise, and interpretability limitations. By the end of the talk, attendees will have a clear understanding of how to start building genetic analysis projects using accessible tools from the Python ecosystem, even without prior bioinformatics experience.
STUART: An Autonomous Hacker Agent Built in Python
What if you give a Python agent an IP address and ask it to find the server's vulnerabilities on its own? That's exactly what I did. In this talk I present STUART, an autonomous pentesting agent I built with AG2 (AutoGen) and GPT-4. The agent can analyze target systems without human intervention, following the first stages of the Cyber Kill Chain: reconnaissance and vulnerability identification. The architecture is 100% Python: an AssistantAgent backed by GPT-4 that reasons and plans, and a UserProxyAgent with a Code Executor that interacts directly with the target system. All orchestrated by AG2, the open-source framework for building multi-agent systems. The talk includes a live demo where STUART will analyze a vulnerable system deployed in Docker. You'll see step by step how the agent scans ports, identifies services, detects vulnerabilities, and reports findings—all autonomously, deciding for itself what to do at each step. Agenda: Introduction: can an LLM find vulnerabilities on its own? (3 min) Cyber Kill Chain: the framework that guides the agent (5 min) STUART architecture: AG2, agents, and real code (7 min) Live demo: STUART analyzing a vulnerable system (8 min) Results, limitations, and next steps (5 min) Closing and Q&A (2 min) You'll take away practical knowledge on how to build agents that act in the real world with AG2, and a concrete perspective on what offensive AI can do today. If a Python agent can find your vulnerabilities, how should defense teams prepare? All demonstrations are performed in controlled, ethical environments.
Vulnerable AI Systems: Real Data, Responsible Design
29% of attacks bypass the security filters of the most widely used LLMs in production. It's not a bug. It's the nature of the system. LLMs are stochastic processes trained on human language—the most flexible, ambiguous, and manipulable medium that exists. That makes them incredibly powerful. And that's exactly why they're vulnerable. There's no patch for that. Only design. This talk presents the results of llm-break-bench: 3,360 adversarial tests on GPT-4o, Claude, Gemini, Grok, and DeepSeek using MLCommons AI Safety v0.5 and OWASP LLM Top 10 as standards. The numbers break intuitions. The smartest model in the benchmark is 5 times more vulnerable than the cheapest and 11 times more expensive. The most criticized by the press ends up second in security, and the reason behind that explains everything that's wrong with how the industry deploys AI today. The data is the starting point. The talk connects them to real use cases where LLMs are in production: RAGs, chatbots, agents, code assistants. It shows where design fails, what consequences it has (Air Canada paid for it), and how to build differently. The closing is actionable: 5 design pillars for AI systems that don't depend on the model for their own security, with real code from NVIDIA NeMo Guardrails and Meta LlamaFirewall. If you have an LLM in production or are about to, this talk changes how you design it.
High-Performance Video Ingestion with Async Python
How do you process multiple video sources in real time without saturating the CPU or losing frames along the way? In this session, we will explore how to break the limitations of traditional workflows through asynchronous architectures. We will analyze how to design an efficient pipeline in Python that achieves concurrent ingestion, processing through AI models, and persistent video storage, all in a decoupled and scalable way. We will share the technical challenges and architecture strategies to move from blocking systems to a robust, high-performance data flow. If you want to take your computer vision projects to the next level and master the power of asyncio, this session is for you.
From Voice to Action: Building an AI Assistant with Python and Google Workspace
Jumping between Gmail, Calendar, Drive, and Jira tabs for repetitive tasks is exhausting. That's why we built Attento, an assistant that lets you execute real actions in Google Workspace using natural language. In this talk we build Attento, an end-to-end voice assistant that turns natural language into real actions across Google Workspace. We'll cover architecture with FastAPI, OAuth 2.0 authentication with PKCE, function calling with Gemini, streaming with NDJSON, best practices with uv and Pydantic Settings, and the path from demo to production with Postgres and automated morning briefings.
Juan Manuel Marín Bedoya
Senior Data Engineer @ Huge
Juliana Suárez Ávila
Data Scientist @ Cuesta Partners
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.
Not Every Nail Needs an AI Hammer: Architectures That Think Before They Generate
We live in an era where everything "needs generative AI"... or so we're told. In this talk I'll cut through the hype to talk about what really matters: designing clean, intentional, and sustainable architectures. We'll explore how to combine the best of the traditional world with emerging tools without falling into over-engineering. Because sometimes a well-placed regex beats a multi-million-parameter LLM. If you're tired of seeing Ferraris parked at the supermarket, this talk is for you.
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.
Hacking AI Agents with Python
Artificial intelligence is evolving from static models to autonomous systems capable of reasoning, making decisions, and executing actions through tools and APIs. These systems, known as AI agents, are primarily built in Python. But with this evolution comes a new attack surface. In this talk we'll explore how AI agents can be exploited from an offensive perspective, using Python to demonstrate real attacks such as: - Prompt injection in agent pipelines - Information exfiltration through RAG - Decision manipulation through adversarial inputs - Abuse of connected tools and APIs From these scenarios, we'll show how to design security testing (pentesting) specific to AI systems, including black-box, gray-box, and white-box approaches. The talk won't focus only on attacks but also on how to mitigate them, presenting a practical roadmap to evaluate and strengthen AI systems in production. This session is aimed at Python developers, data scientists, and engineers building or integrating AI systems who want to understand how to secure what they're creating.
Executable Skills: Teaching an Agent How Your Company Works
The problem, in YC's words (February 2026): "Every company has scattered know-how — in people's heads, in old emails, in Slack threads, in support tickets, and in databases. The company works because humans vaguely remember where that knowledge is. But AI agents do not operate that way." The solution is a Company Brain: a system that extracts knowledge from all those fragmented sources, structures it, keeps it up to date, and turns it into an executable skills archive for AI. This workshop builds, in two hours, a minimal but real Company Brain with pure Python. It is not theory: the code comes from Centinela, a platform already in production serving agricultural operations in Colombia and beverage distributors in Bolivia, and combines the same pieces that at LaHaus have allowed me to bring voice agents to 2.5k+ calls/month with a real SLA. Stack we will touch (all Python or accessible from Python): - Chainlit ≥ 2.9 as conversational interface and thread/step data layer - deepagents (0.4.x) as orchestrator for stateful agentic loops - langchain-anthropic + fallback to Gemini via langchain-google-genai - e2b-code-interpreter as a real sandbox (not mock) to run Python with auditable side effects - Supabase (Postgres + RLS) as multi-tenant control plane - asyncpg for a conversation persistence layer on PostgreSQL - MCP (Model Context Protocol) via langchain-mcp-adapters to plug in external tools
Employability in the Age of AI
Artificial intelligence is changing the job market faster than ever. Many developers wonder: will AI replace me or empower me? In this talk I'll share my real experience going from being a developer in Latin America to working for companies in the United States—facing interviews, optimizing my professional profile, and adapting to an environment where AI is already part of daily life. We'll explore how AI doesn't replace the developer but redefines the value we bring: from writing code to solving real problems, communicating ideas, and building complete solutions. The talk will cover the future of programming, how to shift your mindset toward AI, which skills really matter today, how to stand out in international hiring processes, the role of AI tools in your professional growth, and common mistakes that hold back your employability.
Structured Learning: An AI-powered platform that transforms academic papers into interactive learning experiences.
Structured Learning: The AI Platform That Other AI Agents Build" Subtitle: A real platform that converts academic papers into interactive learning modules, built as a solo developer with an agent pipeline that takes every GitHub issue to a merged PR, on pure Python, async FastAPI, and AWS What do you do when you need to understand and implement a research paper, and existing tools force you to jump between five tabs — PDF viewer, ChatGPT, IDE, notes, a search engine — and every jump breaks context? And what happens when, on the other side of the problem, you're a solo developer trying to build something serious to solve it, with AI agents that usually work well in demos but fall apart in production? This talk is the engineering story of Structured Learning: a platform that converts a research paper into a complete learning module — chapter-by-chapter explanations, incremental executable code, RAG chat, FSRS spaced-repetition flashcards, equation derivations, and a Neo4j knowledge graph connecting concepts across the user's entire library. Nineteen of forty-two features delivered as a solo developer. The product is the visible half. The interesting half is how it was built. The first topic is the product. Where a static tool promises "upload the PDF, get a summary," Structured Learning accompanies the three phases of working with a paper — researching it, understanding it, and applying it — across four custom AI agents in async FastAPI and LiteLLM, with multi-provider support across Anthropic, OpenAI, Google, DeepSeek, and Ollama. The second topic is engineering: an agentic development workflow pipeline that takes a GitHub issue to a merged PR — planning, implementation, tests, review, automatic patching, conflict resolution, documentation, and release. Each phase runs in an isolated git worktree with its own port range, so agents actually run in parallel without checkout contention. Commands in GitHub comments (/plan, /patch, /conflict) trigger background workflows that post phase-by-phase progress back to the same issue, creating a human-readable audit trail. Adaptive routing sends trivial classification to fast, cheap models, and heavy review or debugging to stronger models. PR creation is deferred until all quality gates are green — unit tests, end-to-end tests, and review. When review finds blockers, the pipeline automatically launches a patch workflow to fix them in place and re-runs verification. Real self-repair, no human in the loop for the common "almost right" case. The third topic is production: how this runs on AWS without breaking, and how we develop it locally without paying for cloud. The entire stack — S3 for PDF uploads and TTS audio cache, ECS Fargate for FastAPI backend and GROBID service, RDS PostgreSQL 16 with pgvector extension consolidating application DB and vectors, Secrets Manager for credentials, ECR with immutable image promotion — lives on Terraform with per-environment directory separation. The key to maintaining dev↔prod parity is LocalStack plus a single variable (S3_ENDPOINT_URL): the same boto3 client runs identically on both sides, no code branches, no mocks in tests. docker compose up reproduces the full AWS topology locally, enabling end-to-end flows — paper upload, audio generation, caching — without real credentials or cloud costs during development. You'll leave with a clear view of the product — a platform that covers the three phases of working with an academic paper. For research, it offers conversational search over arXiv and OpenAlex, and a Neo4j graph that detects shared concepts, knowledge gaps, and optimal reading order across your entire library. For explanation, it generates chapter breakdowns with key concepts and diagrams, step-by-step equation derivations that demystify the math, RAG chat and Socratic mode that answers with the paper's full context, and an annotatable PDF reader with "Ask AI" on any selection. And for practical application, it produces executable code that builds incrementally with dependency tracking, FSRS flashcards for measurable long-term retention, and comprehension quizzes that validate understanding chapter by chapter. And with three concrete engineering recipes to reproduce in your own stack. One for building serious AI products without magic frameworks: typed contracts with Pydantic, SSE streaming with cancellation, prompt caching, and per-task cost accounting. Another for scaling a solo developer to team velocity by applying agentic discipline to your own development cycle: isolated worktrees, resumable pipelines, auto-patching after failed review, GitHub as the agents' API. And a third for eliminating "works on my machine" from AWS infrastructure using LocalStack as a local S3 mirror. The thesis: agents don't replace engineers, they replace the glue between engineers and the boring 80% of the SDLC — and that's where compound returns live.
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...
Feeding the Invisible: Food Security in Intermediate Cities with Python
In many countries, food insecurity is not only a social problem but also a data problem. In Colombia, key monitoring systems have lost continuity, leaving critical information gaps for public decision-making. This talk presents the development of a Python prototype to build a monitoring and prediction system for food insecurity risk in intermediate cities, using only open data. From a reproducible pipeline, multiple data science components are integrated: ingestion and processing of food price data (SIPSA), time series models for price forecasting (including classical approaches and machine learning like XGBoost), household segmentation through clustering from socioeconomic surveys, construction of a composite index relating income, prices, and vulnerability, and development of a decision support system (DSS) prototype. Attendees will take away a replicable approach for building complex indicators, strategies for working with imperfect open data, ideas for integrating models, socioeconomic data, and visualization in a single system, and a real example of applying Python in public policy and territorial development.
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.
Build Your AI DJ: Agents in Python and Open Source
What happens when a language model stops just talking about music and starts curating playlists with your real songs? In this workshop we build together, step by step, an AI agent that works as your personal DJ, using Python, 100% open source tools, and connected directly to Spotify. Layer by layer: from an agent that only converses, to one that searches songs, builds real playlists, and remembers your tastes. All local, all open source, all in Python. Each participant leaves with their own working agent.
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.
From ETL to Agentic Workflows: The Evolution of Data Engineering in the Generative AI Era
This hands-on workshop will explore how data engineering is evolving from traditional ETL-based pipelines toward intelligent agent-driven systems capable of reasoning, planning, and executing tasks autonomously. Through hands-on exercises, participants will learn the fundamental concepts behind agentic workflows, the new architectural patterns emerging in the industry, and the modern Python libraries that enable building these types of solutions. Tools for agent creation, task orchestration, integration with language models, and automation of complex processes will be covered. Upon completion, attendees will have built functional examples and will understand how to apply these new capabilities to transform traditional data processes into more dynamic, autonomous, and scalable systems.
Building Your First AI Tool Server: Creating a Pokédex with FastMCP and Python
Do you want your AI applications to do more than answer questions? The Model Context Protocol (MCP) is becoming the standard for connecting language models with tools, APIs, and external systems. In this workshop you will learn to build your first MCP server using FastMCP and Python. Through a completely hands-on experience, we will explore the fundamental concepts of the protocol, how to expose tools, and how to integrate them with compatible clients such as Claude. As the main project, we will build an interactive Pokédex connected to the PokéAPI. Participants will develop real tools to query Pokémon information, expose them through an MCP server, and allow a language model to use them autonomously. Upon completion, you will have developed your own FastMCP server, understand the fundamentals of MCP, and have a solid foundation for creating AI-native applications connected to real data and services. Spots are limited... Gotta catch 'em all!
Daniel Galvis
Senior Analytics Engineer @ Aimpoint Digital
Felipe Sanchez
Analytics Consultant @ Aimpoint Digital
The Fellowship of Agentic Evaluations: How to evaluate an agent?
Autonomous agents are redefining what we can build with LLMs, allowing AI not only to respond but to reason and execute actions across complex flows. However, as we give them more autonomy with tools like LangGraph, a critical engineering problem arises: How do we know if the agent is truly reliable? In this workshop, we will address the challenge of agent evaluation. We do not want to limit ourselves to checking whether the final response sounds good, but to implement different ways of evaluating these agents, ranging from deterministic validations to metrics based on other LLMs (LLM-as-a-judge). For this exercise, we will apply these concepts to the universe of The Lord of the Rings mixed with real medical standards to validate mainly: - Data Integrity: Validate that the agent correctly extracts and formats structured medical codes. - Fidelity: evaluate that the agent does not hallucinate diagnoses. - Observability: Trace and cost monitoring with Langfuse. Upon completion, attendees will have a clear idea of how to answer the question: How to evaluate an agent?
Maria Fernanda Rojas Castro
Advanced Data Engineer @ Loka INC
Nicolas Roldan Fajardo
Advanced Machine Learning Engineer @ Loka INC
From S3 to AI Agent: Your First Queryable Lakehouse
AI agents are only as good as the data they can query. The problem is that most agents built today are connected to outdated CSVs, unstructured databases, or simply nothing. What if your agent could query a real lakehouse — with versioning, schema evolution, and time travel — using natural language? In this workshop we will build exactly that, from scratch, using only open source tools that run on your laptop. What we will build together: Starting from a fully local stack based on Docker Compose, we will set up a functional lakehouse architecture using MinIO as S3-compatible storage, Apache Iceberg as the table format, Project Nessie as a Git-like versioned catalog, and Trino as the SQL query engine. On top of that, we will build an MCP server in Python that exposes our Iceberg tables as tools queryable by an AI agent — and we will finish by connecting Claude so it can query our lakehouse in natural language. What you will learn: How a modern lakehouse really works under the hood — without managed services hiding the magic How Apache Iceberg enables schema evolution, time travel, and row-level deletes on object storage How to build an MCP server in Python that turns SQL queries into tools for AI agents Why this open source architecture mirrors exactly what companies like Netflix, Airbnb, and modern data teams use in production Why open source? We deliberately replace AWS S3 with MinIO, AWS Athena with Trino, and AWS Glue with Project Nessie — not because AWS is bad, but because understanding the real components makes you a better engineer, and because this workshop should be accessible to everyone, regardless of whether you have an AWS account or not. At the end of the workshop you will have a functional lakehouse running on your machine, a working MCP server, and an architecture you can take directly to your next project.
Vision-Language-Action Models: From Chatbots to Interaction with the Physical World
LLM-powered chatbots marked a before and after in artificial intelligence, enabling systems capable of understanding and generating natural language with great fluency. More recently, multimodal models expanded these capabilities by incorporating images, audio, and video, bringing AI closer to a more complete understanding of its environment. In this talk we'll explore Vision-Language-Action Models (VLA), architectures that combine computer vision, natural language, and decision-making to let intelligent agents interpret their environment and execute actions in the physical world. We'll also see how the Python ecosystem has become a fundamental piece for developing these solutions through modern tools like PyTorch, Hugging Face, robotic simulators, and open source frameworks currently used in robotics and multimodal artificial intelligence.
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.
hls4ml: From Python Models to Hardware Acceleration
This session presents a journey from developing machine learning models in Python to their implementation in hardware through the hls4ml tool. The goal is to show how models built in widely used frameworks such as TensorFlow, Keras, or PyTorch can be transformed into efficient hardware descriptions for deployment on reconfigurable devices. The complete workflow will be covered, including model preparation, conversion to High Level Synthesis (HLS) code, and the main hardware optimization criteria such as quantization and precision reduction. The trade-offs between latency, energy consumption, and model accuracy will also be discussed.
Jeronimo Lopez Gomez
Estudiante, Joven Investigador @ Universidad de Antioquia, Grupo de Instrumentacion Cientifica y Microelectronica
Natalia Echeverri Durán
Estudiante @ Universidad de Antioquia, Grupo de Instrumentacion Cientifica y Microelectronica
Building a Transformer with Rust
Transformers are often perceived as incomprehensible giants. This talk aims to prove the opposite: they are not black boxes but elegant mechanisms that can be understood and mastered from their fundamentals. We present Molinete AI, a GPT-2-style model built strictly from scratch in Rust. No deep learning frameworks—just tensors, math, and full control. Inspired by Feste from Tag1 Consulting (trained on Shakespeare), this project poses a different challenge: training the network on Miguel de Cervantes's work to generate text in the style of the Golden Age. Throughout the session we'll break the model down piece by piece. With the support of a Manim animated presentation (over 4,000 lines of code), we'll make visible how information flows inside the network. We'll start from tokenization (BPE) and building basic operations, then dive into the core of the model: embeddings, causal mask, and Multi-Head Self-Attention. Finally, we'll explore the learning process, watching how gradients flow through the network during training. More than a demo, this talk aims to provide a clear, operational view of Transformers, connecting theory with a real from-scratch implementation.
NLP Without Labels: How to Cluster N Legal Processes of the Colombian State and Turn Chaos into a Production Classifier
What do you do when you have 600,000 legal complaints, zero labeled data, and a government entity waiting for results? This talk walks through the full process of building an unsupervised NLP classification system for the Procuraduría General de la Nación. Starting from raw administrative text—noisy, full of abbreviations and institutional jargon—I'll show how TF-IDF, truncated SVD, and KMeans combined to organize more than half a million records into 64 semantically coherent groups, without a single manual label. But clustering is only the starting point. I'll cover how clusters were validated, how a Logistic Regression classifier was trained on them to make the system deployable, and how the final pipeline was packaged in a .pkl that non-technical colleagues use in production today. Along the way we'll face real problems: elbow curves that don't behave, 1:20 size imbalances between clusters, and the tension between mathematical elegance and institutional usability. Because in the public sector, a model nobody uses isn't a model—it's a PDF gathering dust.
Cost Optimization Strategies for GenAI with Python and AWS
Is it possible to scale Generative AI without project success compromising the organization's financial stability? This session will address how to transform the deployment of large language models (LLMs) through architecture design oriented toward operational efficiency. Instead of accepting high token consumption as an inevitable cost, we'll explore a sustainable cost model that lets you build intelligent, scalable applications without sacrificing profitability. Through a technical path centered on Python and AWS services, we'll analyze key strategies such as model arbitrage, where application logic dynamically decides which intelligence engine to use based on task complexity. We'll dive into how smart use of low-impact vector databases and semantic caching reuse prior knowledge, achieving significant infrastructure savings. Attendees will discover how implementing async flows and batch processing optimizes available resources. This talk is a practical guide for architects and developers looking to lead the transition from costly prototypes to production systems that are technically and economically viable.
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.
LangGraph and Strands Agents: Core Concepts, Patterns, and Tradeoffs
The agent framework landscape has consolidated fast. Among the options available today, two stand out for their architectural depth and production relevance: LangGraph, with its graph-based, developer-controlled orchestration model; and Strands Agents, with its model-driven, minimal-scaffolding approach. They are not interchangeable — they represent different answers to the same fundamental question of how much control a developer should retain over agent behavior. This workshop is a structured, hands-on exploration of both. Participants will work through a shared codebase covering real scenarios: tool calling, state management, multi-turn reasoning, and multi-agent coordination. Each scenario is implemented in both frameworks side by side, making the architectural differences concrete and comparable rather than theoretical. The session is organized around three axes: core concepts (how each framework models state, tools, memory, and control flow), practical patterns (what each one makes easy, what it makes hard), and honest tradeoffs (where each framework earns its complexity and where it doesn't). No polished demos — just real code, real outputs, and an open discussion of what each approach costs and buys you. By the end, participants will have a working mental model for both frameworks, hands-on exposure to their key patterns, and enough grounded perspective to make an informed architectural decision on their next agentic project. Suitable for: Python developers with some familiarity with LLMs or agent concepts. Production experience is a plus but not required — the workshop is designed to reward depth of engagement, not prior framework knowledge.
Isabel Mora
Junior Machine Learning Engineer @ Loka
Jose Hernan Ortiz Ocampo
Senior Machine Learning Engineer @ Loka
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
Your LLM Is Bleeding Money and Python Can Stop It
You put your LLM in production. It responds, it works, users use it. But there are questions you cannot answer: how much did it cost you exactly last week? Which prompt consumes the most tokens? Why was that response terrible on Tuesday at 3pm? How do you show the business that the system is improving? Most teams working with LLMs today operate blind. They deploy, receive complaints, adjust prompts without data, and get API bills that no one can explain. That is not engineering — it is expensive intuition. In this workshop you will build, line by line in Python, a complete observability system for LLM applications using OpenTelemetry, Langfuse, and Elasticsearch. No theory, no endless slides — real code you can take to your project the following Monday. What you will build: We start from a document Q&A agent that appears functional but is completely blind. During the workshop we instrument it step by step: first with Langfuse @observe decorators to capture every prompt, response, and token count; then we export those traces via OpenTelemetry to Elasticsearch, where we build a live Kibana dashboard showing cost per user, p95 latency per model, and low-quality response rate. Finally we implement an automatic evaluation layer with LLM-as-a-judge so the system audits itself. At the end of the workshop you have a functional, open source, self-hostable stack — without depending on closed SaaS platforms — that any team can adopt regardless of whether they use OpenAI, Anthropic, or local models via Ollama. What you take away: Complete GitHub repository with Docker Compose ready to spin up the environment, notebooks with each workshop step, and an exportable Kibana dashboard template. Everything in Spanish, documented so you can share it with your team. Who is this workshop for? For Python developers who already have basic experience with LLMs and APIs, and who are ready to take the step from "my POC works" to "my production system is reliable, measurable, and defensible to the business." You do not need prior experience with OpenTelemetry or Elasticsearch — we explain them from scratch in the context of LLMs. Why does this matter now? Global spending on LLM APIs doubled in less than six months. 47% of companies are running observability pilots for AI but only 7% have it in production. The gap between making an LLM work and operating it responsibly is the most urgent technical problem the industry has today — and Python has all the tools to close it.
LLMs in Depth: How an LLM Works Mathematically (and Its Implementation with PyTorch)
Imagine a 30-minute space where mathematics, code, thought experiments, and one of the most attractive topics of the present converge during powerful minutes — that is what this presentation seeks. The goal of this talk is to review each of the components of a Large Language Model (LLM), from the embedding system and the BPE algorithm to the attention mechanism that is the core of modern AI, passing through normalization and the small "tricks" used in both training and inference to improve results and make LLMs more optimal. Each of these components will be addressed from three perspectives: 1) the pure mathematics that composes the solution, 2) the interpretation of this mathematics (why it is useful and how we can visualize it), and 3) the implementation in code, where small code snippets will show how these systems are implemented in Python. At the end, an open-source code repository will be provided with the full implementation and training pipeline for a "playground model" implementing a GPT-style model. The intention with this talk is not only to shed light on one of the most interesting and complex topics in the modern world, but also to provide tools to question how these systems work and promote research in this field.
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.
Elevate your code quality in Python with modern, ultra-fast tooling
AI coding assistants have changed how we build software. We can now generate features, refactors, and entire services in minutes — but speed without strong engineering practices quickly becomes technical debt. In this talk, I'll show how modern Python teams can build fast and reliable development workflows using tools like Astral's Ruff, Ty, and uv. We'll explore how traditional slow and noisy quality pipelines are being replaced by a new generation of tooling that provides near-instant feedback while improving code quality and developer experience. Topics include: Why AI-generated code makes automated quality gates more important than ever Using Ruff for formatting, linting, and fast feedback loops Using Ty for modern static typing and safer large-scale development Structuring formatter → linter → type-checker workflows Pre-commit hooks and CI pipelines developers actually enjoy using Reducing friction between local development and CI/CD The session is practical, opinionated, and based on real-world engineering experience building production systems with AI-assisted workflows. Whether you are a backend engineer, tech lead, or AI-native developer, this talk will give you a modern blueprint for building Python systems that move fast without sacrificing quality.
From Notebook to Production: End-to-End MLOps on Databricks
Is your Machine Learning model trapped in a Notebook or does it actually generate value in production? Taking ML models into the real world requires more than just good training code; it demands a solid MLOps strategy. In this hands-on workshop, we will transform a use case from scratch into an industrial-grade solution using Databricks and MLflow. Through a hands-on approach and using Databricks Free Edition, attendees will master the complete lifecycle (End-to-End) under professional standards. Workshop Agenda: - Industrialization Fundamentals: Introduction to Lakehouse architecture, MLflow as an industry standard, and the role of the Feature Store in reproducibility. - Engineering and Governance: Creating a Feature Store and managing raw data with best practices. - Scalable Training: Developing models with exhaustive experiment tracking and a bonus on distributed training for large data volumes. - Deployment Strategies: Analysis of trade-offs between Batch Inferencing and Real-time Serving (Model Serving). We will implement "Deploy Code" and "Deploy Artifacts" patterns. - Modern Operationalization: Professional orchestration through Databricks Asset Bundles (DABs), the definitive tool for infrastructure as code on Databricks. - The finishing touch (CI/CD): How to integrate everything into a continuous deployment pipeline to guarantee quality across multiple environments. Outcome for attendees: Upon completion, each participant will have the source code, infrastructure configuration, and a productized, orchestrated ML model ready to be replicated in real environments.
Patterns, Protocols and Tactics for Multi-Agent Systems
As LLM applications evolve, Multi-Agent Systems (MAS) are becoming the new standard for complex automation. But how do agents effectively communicate and collaborate? This session breaks down the protocols and tactical patterns of MAS. From basic routing to advanced collaborative architectures, discover how to use Python to build systems where agents work in harmony.
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
Fine-tuning at Nequi: Teaching a Small Model the Language of Our Transactions
At Nequi, a transaction is not just an amount and a date — it is behavior, context, and sequence. Generalist models do not capture that semantics, and rigid rules do not scale with millions of users. In this workshop we explore hands-on how to fine-tune a small model so it learns the language of transactional events: their patterns, anomalies, and risk signals. Participants will work from dataset construction to model validation, understanding at each step which decisions matter and why
Angie Katherine Reyes
AI Builder & Team Lead @ Nequi
Elkin Javier Guerra Galeano
Machine Learning Engineer | MLOps @ Nequi
Real-Time Voice Systems: Design and Architecture in 5 Levels
Voice systems have advanced rapidly in recent years, but most implementations still stop at demos: simple combinations of Speech-to-Text, language models, and Text-to-Speech that work in controlled environments but fail when facing real-world conditions. This talk proposes a different approach: understanding voice systems as an architecture that evolves through maturity levels, from basic prototypes to real-time production-ready systems. Through a 5-level framework, we'll walk the full path of a Conversational AI system: from integrating basic components, through orchestration challenges (streaming, latency, turn-taking), to less obvious but critical problems like audio quality, robustness, and user experience, reaching real-time architectures with technologies like LiveKit, and finally exploring where the future is headed with end-to-end systems and multimodal agents. The talk is based on real experience building voice systems in production and focuses on engineering decisions more than specific tools. Attendees will leave with a clear understanding of how to design modern voice systems with Python, what problems to anticipate, and how to structure their own architectures to build world-class conversational experiences.
Python and Machine Learning for Sustainable Thermochemical Optimization
Chemical engineering still relies heavily on costly, slow experimental trials to evaluate operating conditions in thermochemical processes. This talk proposes a practical approach based on Python and machine learning to accelerate that process: building predictive models from physicochemical data that estimate key outcomes without testing every scenario in the lab. A complete flow oriented toward real applications will be shown, from data to decisions, with the goal of reducing analysis time, lowering experimental costs, and supporting process optimization with environmental impact.
NLP in Practice: From Corpus Linguistics to RAG with Python
Natural language processing today offers a mature set of tools for analyzing textual corpora systematically and reproducibly, but the path between having the documents and obtaining results is not always clear. This workshop covers that path from start to finish. In two hours, participants will build an understanding of the NLP ecosystem: its history, logic, and methods. The session opens with a timeline from the earliest rule-based models to transformers, followed by a map of techniques organized by problem type (classification, entity extraction, semantic search, generation) so each participant can identify which method they need for a specific textual problem. The second part covers two implementations with Python. First, topic modeling with BERTopic, reviewing the internal pipeline of embeddings, UMAP, and HDBSCAN. Second, a conversational assistant with RAG: corpus indexing, semantic retrieval, and connection with a language model to answer queries about the documents. Upon completion, each participant will have a functional notebook with both pipelines and a clear map of the ecosystem to guide their own textual analysis projects.
Andrés Felipe Puerta Velez
Asistente de investigación y estudiante de maestría en matemáticas aplicadas. @ Universidad EAFIT
Biviana Marcela Suárez Sierra
Profesora vinculada al área de Computación y analística @ Universidad EAFIT
Dora Cecilia Alzate Gallo
Estudiante de la Maestría en Estudios Humanísticos @ EAFIT
Karen Melissa Gomez Montoya
Ingeniera matemática - Asistente en investigación @ Universidad EAFIT
NORTH: Claude as a Real Copilot
We all use AI to program. Few use it well. Most developers interact with Claude or any LLM as if it were Google with superpowers: they ask a question, receive an answer, copy and paste, unstructured prompts. The next day, the AI has no idea who you are, what project you are working on, or why you chose PostgreSQL over MongoDB last week. Every session starts from zero. Every time you re-explain the same thing. And the result is brilliant answers that do not know your code. How serious is this? I measured it. I asked Claude exactly the same thing — "give me the complete project context" — with and without methodology. Without structured context, Claude detected 3 of 5 team members, found 3 different versions of the project without knowing which was real, could not identify technical debt, and had no idea about the current sprint. With NORTH, the answer was precise: complete team with roles, correct canonical version, 3 technical debt items with severity, defined sprint with priorities, and pending PR to merge. Usefulness score: 7/7 with NORTH vs 2.5/7 without it. Same tokens. Same cost. The difference is not money — it is useful information vs noise. What if with a single command — /north — Claude knew exactly where you left off and what comes next? That is NORTH. A methodology that turns Claude into a real development copilot. Not a chatbot that answers questions — an agent with live memory of your project.
Build an OpenClaw-style Coding Assistant on WhatsApp with Claude Agent SDK
In this hands-on 2-hour workshop, participants will build a personal coding assistant using Claude Agent SDK (powered by Claude Code) and turn it into a powerful OpenClaw-style agent they can talk to through WhatsApp. We'll start by building the core agent in Python with Claude Agent SDK, then progressively add advanced capabilities: memory so it remembers context across conversations, subagents to handle specialized tasks, hooks to customize its behavior, and other advanced agent features that make it genuinely useful. Once the agent is solid, we'll connect it to WhatsApp using Evolution API (Baileys-based, attendees just scan a QR code) so they can interact with it naturally from their phone, just like talking to a colleague. By the end of the session, attendees will use their assistant to build a real web app, demonstrating how a well-designed agent can become a true coding copilot. They'll leave with a working OpenClaw-style assistant connected to their WhatsApp, a real web app they built with it, and a framework they can extend to other personal and professional use cases.
From Typosquatting to Infrastructure Poisoning
In 2026, Python supply chain security has moved beyond misspelled package names to become an infrastructure battlefield. This talk analyzes the technical transition from simple Typosquatting attacks to sophisticated poisoning of CI/CD tools and runtime environments. We'll explore recent real cases such as the TeamPCP campaign and the Aqua Security Trivy compromise, analyzing persistence techniques through .pth files that enable malicious execution without an explicit import. Finally, we'll present the roadmap for modern defense: from Sigstore and PEP 740 to compliance with the Cyber Resilience Act (CRA).
Clean Code in the Era of LLMs: Do Good Practices Still Matter?
Instead, research from METR, CodeRabbit, and GitClear is converging on an uncomfortable truth: code duplication has quadrupled, copy-pasted code now exceeds moved code, bugs have risen 70%, and security issues have nearly tripled. AI didn't break our codebases. It amplified what was already broken. So what do we actually do about it? Do decades of hard-won engineering wisdom still apply when a model writes half the code, or do we need a new playbook entirely? Are clean code, SOLID, DDD, TDD, and the design patterns we've spent decades arguing about dead weight in the age of Claude Code and Copilot, or do they matter more than ever? This talk makes the case for the second answer. Your codebase is now a prompt: clean code leads to better AI suggestions, which make it easier to stay clean. Messy code leads to worse suggestions, which make it harder to recover. We'll walk through which practices now matter more (SOLID, DDD, TDD), which ones have quietly turned against you (hello, aggressive DRY and Abstract Factories), and how to collaborate with an LLM without becoming a rubber stamp for its output. You'll leave with a concrete framework, Adversarial Collaboration, that you can apply the next morning: generate, critique, refactor, verify. Not vibe coding. Not perfectionist prompting. Real engineering, just faster.
From Prompts to Agents: Intelligent Systems with Python
Prompts are only the beginning. The real power of modern artificial intelligence lies in transforming those instructions into structured systems capable of reasoning, applying rules, and generating consistent decisions. In this hands-on workshop, participants will go beyond basic prompt usage and learn to design and build intelligent agents using Python. Starting from a simple prompt, we will progressively evolve it into a functional agent that processes information, applies context, and generates structured responses. Through a practical approach, we will learn to: Design effective prompts with clear context, objectives, and constraints Structure responses in reliable formats (such as JSON) Build a simple agent in Python that transforms questions into decisions Incorporate context and memory to improve results Evaluate the quality and consistency of responses At the end of the workshop, each participant will have their own agent-style system, capable of converting inputs into useful recommendations, along with a reusable framework to apply to real problems. This workshop is aimed at developers, data professionals, and curious people who want to move from using AI tools to designing intelligent systems. No prior AI experience is required, only basic Python knowledge and a desire to learn. More than a technical session, this workshop proposes a new way of understanding AI: not only as a tool that responds, but as a system we can design.
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.
Understanding Cognitive Complexity in Python
Modern Python makes it incredibly easy to write code quickly, but much harder to keep it understandable as projects grow. This talk explores cognitive complexity: a metric focused not on what code does, but on how difficult it is for humans to read, reason about, and maintain. Through real Python examples, we will analyze how nested conditionals, branching logic, async flows, exceptions, and growing business rules silently increase the mental load required to work with a codebase. We will also discuss why traditional metrics such as cyclomatic complexity often fail to reflect actual readability, and how cognitive complexity provides a more human-centered perspective on maintainability. The talk includes practical refactoring techniques, common anti-patterns found in production Python projects, and lessons learned while building complexipy, an open source cognitive complexity analyzer for Python written in Rust, designed to provide fast local feedback and CI integration.
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.
Lessons Learned Reporting Vulnerabilities in the Python Ecosystem
You've surely received that notification telling you to update a dependency due to a security flaw. But have you wondered what happens from when someone discovers that vulnerability until the patch reaches your project? In this talk I'll share my experience reporting vulnerabilities in the Python ecosystem. We'll explore the behind the scenes: from the technical finding and reporting process to collaboration with maintainers and patch publication. We'll address not only technical aspects but also the human factor—both crucial for effective vulnerability resolution. The challenges maintainers and the community face, especially in this new era of open source software security where artificial intelligence plays an increasingly relevant role.
Camila Plejia, Virtual Assistant Applied to People with Tetraplegia
The combination of different tools and technologies in artificial intelligence—Computer Vision, OCR, NLP, RPA, Voice to text, text to voice—gives rise to a virtual assistant, Camila Plejia, that helps people with tetraplegia, facilitating their daily tasks such as reading news, checking the weather, reviewing, reading and writing email, reviewing, sending and reading WhatsApp messages, searching for and watching a specific video on YouTube, among others. It allows a person with tetraplegia to have a window of communication with the outside world, considering they spend much time isolated between four walls and depend on a third party's assistance to perform activities.
Dashboards That Think: Build Agentic Analytics with Sigma
Traditional dashboards only show data: you ask, they answer, and you start over. In this hands-on workshop we will take the next leap: we will build an agentic dashboard in Sigma that reasons about data, applies business logic, and executes actions, without writing code. Working on live data in the warehouse, you will learn step by step to: design a dashboard on Sigma's canvas; incorporate Sigma Agents to answer questions in natural language, chain multiple reasoning steps, and trigger workflows; and connect the dashboard with external tools and systems via MCP, all governed and without taking data out of your platform. In the end you will have an intelligent dashboard working end to end that you can replicate in your own work. It is an ideal session to understand, hands on keyboard, what "agentic analytics" really means in today's AI conversations, and how anyone can build it without being a data engineer or analyst
Beyond Vibe Coding: Spec Driven Development with Code Graphs
Artificial intelligence is changing the way we build software, but writing prompts and accepting code suggestions is not enough to work on real systems. In applications with multiple layers, dependencies, and business rules, the real challenge is not just generating code, but understanding where to change it, how it impacts the system, and how to validate it correctly. In this workshop you will explore an evolution of Spec Driven Development using Code Graphs as a structured context source. Starting from a web application built with FastAPI, you will work on a specific feature following a guided flow: requirement, specification, graph context, planning, tasks, implementation, and validation. During the session you will learn the Spec Driven Development flow, from defining the requirement to creating the specification, planning, generating tasks, implementation, and validation. You will also see how a code graph can represent files, functions, classes, relationships, and dependencies, allowing AI not to depend solely on textual context or isolated prompts. This will help you reduce common errors such as duplicating logic, modifying incorrect layers, or ignoring affected tests. Upon completion, you will understand how to move from improvised use of AI in development to a more structured, traceable, and reliable process. You will learn to combine specifications, real code context, and AI assistance to build software with greater technical clarity, better impact validation, and logic applicable to real projects.
Esneider Bravo Benitez
Software Engineer @ Muno Labs
Jonathan Vallejo Muñoz
Senior Director of Software Engineering @ Lendingfront
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!
Use it or lose it! Token diet with TOON to fatten your wallet and help AI understand more
What if we told you that every time you send JSON to an LLM you are paying an invisible "tax"? In the Generative AI era tokens are the new gold, and with standard JSON (with its redundant braces and repeated keys) you are burning them. In this session we will review the history of data notation to understand why current tools are not optimized for LLMs and we will present TOON (Token-Oriented Object Notation), a notation that combines the best of two worlds: the readability of YAML and the density of CSV. But we will not only talk theory, we will also work with real data and see how TOON manages to reduce token consumption compared to JSON. We will also demonstrate something important: spending less does not mean understanding less! Because just by using TOON many benchmarks show improvements in their metrics. It is time to put your data on a diet!
