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
AI is transforming not just what engineers build, but how they learn and grow. In this workshop, you'll discover AI-DLC (AI-Driven Learning Curriculum), a framework for creating personalized, adaptive learning paths for software engineers using AI tools. We'll explore how to design learning curricula that incorporate AI assistance, build skills that complement rather than compete with AI, and create development plans that keep engineers relevant and valuable for years to come.
Carlos Alberto Riveros Varela
Software Engineer @ EPAM Systems
Jesús Alfredo Reyes Vargas
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. 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. 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 smartest model in the benchmark is 5 times more vulnerable than the cheapest. The data connects to real use cases where LLMs are in production: RAGs, chatbots, agents, code assistants. 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.
High-Performance Video Ingestion with Async Python
Video is one of the most demanding data types to process. In this workshop, you'll learn how to build high-performance video ingestion pipelines using Python's async capabilities. We'll cover asyncio fundamentals for I/O-bound video processing, concurrent frame extraction and processing, async queue patterns for data pipelines, performance profiling and optimization, and real-world deployment considerations. Build a production-grade async video ingestion system from scratch.
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
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.
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, and 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: How to Teach an Agent How Your Company Works
How do you make an AI agent that truly understands how your company works? In this workshop, you'll learn to design and implement executable skills—reusable, structured pieces of organizational knowledge that agents can invoke. We'll cover skill architecture, knowledge representation in Python, integrating skills with popular agent frameworks, and testing skill reliability. By the end, you'll have a blueprint for building a company brain that your agents can tap into.
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: AI-Powered Platform That Transforms Academic Papers into Interactive Learning Experiences
Structured Learning is a platform that turns 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 knowledge graph in Neo4j. This talk covers the product, the engineering of an agentic workflow pipeline that takes a GitHub issue to a merged PR with isolated worktrees, auto-patching after failed review, and GitHub as the agents' API, and how it runs on AWS with LocalStack for dev-prod parity. 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.
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.
Create Your AI DJ: Agents in Python and Open Source
Create your own AI DJ using Python agents and open-source tools! In this beginner-friendly workshop, you'll learn the fundamentals of AI agents, build a music recommendation system powered by Python, and connect it to real music APIs. No prior AI experience required—just curiosity and a love for music. By the end, you'll have a working AI DJ that curates playlists based on mood, genre, and personal preferences.
From ETL to Agentic Workflows: The Evolution of Data Engineering in the Generative AI Era
Traditional ETL pipelines are deterministic and rigid. Agentic workflows powered by generative AI can adapt, reason, and handle the unexpected. In this workshop, you'll learn how to evolve your data engineering practices from classic ETL to intelligent agentic workflows. We'll cover designing agents for data extraction, transformation decisions, and loading strategies—as well as how to combine traditional orchestration tools with AI agents for hybrid architectures.
Building Your First AI Tool Server: Creating a Pokédex with FastMCP and Python
Build your first AI tool server from scratch using FastMCP and Python, with the Pokédex as your guide! In this hands-on workshop, you'll learn the Model Context Protocol (MCP), set up a FastMCP server, implement custom tools that AI agents can call, and connect everything into a working Pokédex AI assistant. No prior MCP experience needed—just Python knowledge and a love for Pokémon.
The Fellowship of Agentic Evaluations: How to Evaluate an Agent?
How do you know if your AI agent is actually doing the right thing? In this workshop, we'll explore practical evaluation frameworks for agentic systems. Forming a fellowship of evaluation techniques—from simple unit tests to complex behavioral evaluations—we'll apply them to real agent scenarios. You'll learn to define evaluation criteria, implement automated test suites, measure agent performance quantitatively, and track improvement over time.
From S3 to AI Agent: Your First Queryable Lakehouse
AI agents are only as good as the data they can query. Most agents built today connect to outdated CSVs, unstructured databases, or nothing at all. What if your agent could query a real lakehouse—with versioning, schema evolution, and time travel—using natural language? In this workshop we build exactly that from scratch using only open-source tools that run on your laptop. Starting from a local Docker Compose stack, we stand up a functional lakehouse with 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 build a Python MCP server that exposes Iceberg tables as tools for an AI agent, and connect Claude so it can query the lakehouse in natural language.
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: the Pipeline pattern with a fluent Pipeline → Step → Run → Manifest API built on Pydantic v2; one API across eleven providers; provenance that survives the file with SHA-256-verified manifests embedded into PNG, JPEG, MP4, MP3, and WAV; privacy and policy controls; storage and replay; and agent loops with lineage. By the end, attendees will have a clear 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
Bridge the gap between Python machine learning and hardware implementation using hls4ml. In this workshop, you'll learn how to take ML models trained in Python (TensorFlow, PyTorch, scikit-learn) and deploy them to FPGAs using the hls4ml library. We'll cover model quantization, hardware-aware training, the HLS synthesis workflow, performance profiling, and practical considerations for deploying ML at the edge. No prior FPGA experience required.
Jerónimo López Gómez
Researcher @ Universidad de Antioquia
Natalia Echeverri Durán
Researcher @ Universidad de Antioquia
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.
LangGraph and Strands Agents: Core Concepts, Patterns, and Tradeoffs
Dive deep into two powerful agentic frameworks—LangGraph and Strands Agents—and learn when to use each. This advanced workshop covers the core concepts behind both frameworks: state machines, graph-based orchestration, tool use, and memory management. We'll build the same agentic application in both frameworks, compare their strengths and limitations, and discuss the architectural trade-offs to help you choose the right tool for your production AI systems.
Your LLM Is Bleeding Money and Python Can Stop It
Every token your LLM processes costs money, and without proper observability, costs can spiral out of control. In this workshop, you'll learn how to instrument your Python LLM applications to track token usage, latency, and cost per request. We'll build a complete observability stack using open-source tools, set up alerts for cost anomalies, and implement strategies to cut your LLM bill without sacrificing quality.
LLMs in Depth: How an LLM Works Mathematically (and Its Implementation with PyTorch)
Demystify the mathematics behind Large Language Models and implement them from scratch in PyTorch. This advanced workshop takes you through the complete mathematical foundations: attention mechanisms, transformer architecture, positional encodings, layer normalization, and training dynamics. For each mathematical concept, we'll write the corresponding PyTorch implementation—giving you a deep, hands-on understanding of how LLMs actually work under the hood.
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 and linting, using Ty for modern static typing, structuring formatter → linter → type-checker workflows, pre-commit hooks and CI pipelines developers actually enjoy using, and reducing friction between local development and CI/CD.
From Notebook to Production: End-to-End MLOps on Databricks
Move beyond Jupyter notebooks and deploy machine learning models to production using MLOps best practices on Databricks. In this intermediate workshop, you'll learn to structure ML projects for production, implement CI/CD pipelines for models, manage experiments with MLflow, deploy models as REST APIs, and monitor them in production. We'll walk through a complete end-to-end example from data preparation to automated retraining.
Patterns, Protocols and Tactics for Multi-Agent Systems
Master the essential patterns, protocols, and tactics for building robust multi-agent systems in Python. In this workshop, you'll learn proven architectural patterns for multi-agent collaboration, communication protocols between agents, error handling and recovery strategies, and practical implementation tactics. Drawing from real-world experience, we'll build multiple agent architectures and analyze their trade-offs—giving you a reusable toolkit for designing multi-agent systems.
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
Bridge the gap between traditional corpus linguistics and modern Retrieval-Augmented Generation (RAG) systems. In this workshop, researchers and developers will learn how classical NLP techniques—corpus analysis, tokenization, and annotation—can inform and improve RAG implementations. We'll use Python to build a pipeline that takes a text corpus from raw collection through linguistic analysis to a queryable RAG system, demonstrating how academic NLP foundations enhance practical AI applications.
Biviana Marcela Suárez Sierra
Researcher @ Universidad EAFIT
Dora Cecilia Alzate Gallo
Researcher @ Universidad EAFIT
NORTH: Claude as a Real Copilot
Learn how NORTH uses Claude as a genuine coding copilot—not just a code completer, but a true engineering partner. In this workshop, you'll explore the architecture of NORTH and learn how to build similar AI copilot integrations using Claude's API and Python. We'll cover prompt engineering for coding assistance, maintaining context across long sessions, integrating with development workflows, and building the feedback loops that make AI copilots genuinely useful.
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? This talk makes the case that clean code, SOLID, DDD, TDD, and design patterns matter more than ever when LLMs write half the code. Your codebase is now a prompt: clean code leads to better AI suggestions, which make it easier to stay clean. We'll walk through which practices now matter more, which ones have quietly turned against you, and how to collaborate with an LLM without becoming a rubber stamp for its output. You'll leave with a concrete framework, Adversarial Collaboration: generate, critique, refactor, verify. Not vibe coding. Real engineering, just faster.
From Prompts to Agents: Intelligent Systems with Python
Take your first steps from writing simple prompts to building intelligent multi-agent systems with Python. In this beginner-friendly workshop, you'll learn the foundations of AI agents, how they differ from simple LLM calls, how to chain agents together for complex tasks, and how to give them tools and memory. Using popular Python frameworks, you'll build a working multi-agent system by the end of the session—no prior AI experience needed.
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.
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
Learn how to build dashboards that don't just display data—they think. In this workshop, you'll combine Sigma's business intelligence capabilities with Python-based AI agents to create agentic analytics dashboards. We'll cover integrating LLMs with Sigma, building agent-driven data narratives, automating insight discovery, and creating dashboards that can answer follow-up questions and adapt dynamically to user context.
Beyond Vibe Coding: Spec Driven Development with Code Graphs
Go beyond vibe coding and learn how to use specifications and code graphs to guide AI-assisted development. In this workshop, you'll discover how structured specs and dependency graphs give AI coding tools the context they need to produce coherent, maintainable code. We'll work with real Python projects to define specs, generate code graphs, and wire them into your AI-assisted workflow—resulting in code that actually makes sense architecturally.
Esneider Bravo Benítez
Software Engineer @ Lendingfront
Jonathan Vallejo Muñoz
Software Engineer @ Lendingfront
Now or Never! Token Diet with TOON to Save Money and Help AI Understand More
Tokens cost money, and every unnecessary token you send to an LLM is money wasted. In this workshop, you'll learn how to put your AI applications on a token diet using TOON, a Python tool for creating compact, semantically rich data representations. We'll cover TOON's architecture, how to serialize complex data structures efficiently, measure token reduction, and integrate TOON into existing AI pipelines—without losing the information your models need.
