PyData Boston 2025

This 90-minute hands-on tutorial teaches participants how to build LLM agents that automate real workflows using LlamaBot—a Pythonic interface to language models—and Marimo notebooks for interactive development.

The tutorial follows a single, realistic workflow from start to finish: automating back-office tasks for receipt processing and invoice generation. We'll build three agents that work together: a receipt processor that extracts data from PDF receipts, an invoice writer that generates invoices from structured data, and a back-office agent that coordinates between them. This demonstrates the fundamental pattern for building agentic systems: start by mapping the workflow, build focused agents for specific tasks, then compose them.

What participants will learn: The most important lesson: map your repetitive workflows before writing any code. Participants will learn how to identify boring, repetitive work worth automating, break workflows into agent tasks, and build systems where agents use other agents as tools.

Technical skills include setting up local LLM development with Ollama, building agents with decision-making loops, defining tools that agents can use, composing agents by exposing them as tools for other agents, and debugging agent behavior in interactive notebooks.

Tutorial structure:
Setup verification (5 minutes): Quick check that all participants have dependencies installed and Ollama models downloaded. Brief overview of Marimo notebooks.

Part 1: Workflow mapping comes first (10 minutes): Walking through the back-office workflow from receipts to invoices, identifying decision points where agents add value, and breaking down the workflow into agent tasks before writing any code.

Part 2: Building the receipt processor agent (20 minutes): Hands-on building of a receipt processor agent that takes PDF receipts, extracts images, and uses a vision language model to extract structured data (vendor, date, items, amounts). Participants learn to define tools, build decision-making loops, and debug agent behavior.

Part 3: Building the invoice writer agent (20 minutes): Hands-on building of an invoice writer agent that takes structured data and generates formatted invoices. Covers agents for generation vs extraction and handling missing or invalid data.

Part 4: Composing agents—the back-office coordinator (25 minutes): Hands-on building of a coordinator agent that uses the receipt processor and invoice writer as tools. Participants learn the key pattern of agents as tools for other agents, watch the coordinator decide when to call each specialized agent, and understand how to extend the system by adding new agents.

Part 5: Integration and next steps (10 minutes): Moving from notebook to production, local vs cloud models, best practices for workflow-based agent systems, and applying this pattern to participants' own workflows. Open discussion and questions.

Why this approach works: Most agent tutorials start with technology and hope you'll figure out what to do with it. This tutorial starts with a workflow everyone recognizes—processing receipts and generating invoices—and shows you how to automate it step by step.

The receipt-to-invoice workflow is perfect for teaching because it's immediately relatable, demonstrates real workflow automation with multiple steps and coordination, shows agent composition, and is easily extensible to other workflows.

The tutorial follows a natural progression: map the boring work first, build focused agents that do one thing well, compose agents by having coordinators delegate to specialists, then integrate into real work. Using LlamaBot and Marimo together is particularly powerful because LlamaBot's Pythonic design makes agent composition straightforward, and Marimo's reactive execution means participants can experiment with workflow changes and see results immediately.

Target audience: This tutorial is designed for anyone tired of repetitive back-office work like processing receipts and invoices, data scientists and analysts who want to automate boring workflows they've already mastered, Python developers looking to understand how to build practical agent systems, and anyone who looks at their daily tasks and thinks "there has to be a better way."

Participants should be comfortable with intermediate Python (functions, classes, type hints) and have a basic conceptual understanding of LLMs. No prior experience with agent frameworks is required—the tutorial is designed to demystify agents by starting with workflows you actually want to automate.

Takeaways: Participants will leave with the workflow-first mindset for mapping repetitive work before building agents, working code for three composed agents (receipt processor, invoice writer, coordinator), understanding of agent composition and how agents can use other agents as tools, the fundamental pattern for building agentic systems, practical strategies for integrating agent systems into real work, experience debugging agent decision-making and coordination, a GitHub repository of examples to reference, and confidence to map their own boring workflows and automate them.