How I AI

How Block’s custom AI agent supercharges every team, from sales to data to engineering

VP of engineering Jackie Brosamer and principal engineer Brad Axen join me to demo Goose, Block’s open-source AI agent that runs locally, plugs into your existing tools through model context protocol (MCP) servers, and peels away the rote parts of work so people can focus on insight and impact. This episode is packed with in-depth demos: starting with a messy farm-stand sales CSV, Goose analyzes the data, builds visualizations, and generates a shareable HTML report. We then spin up an MCP that lets Goose talk to Square’s dashboard for inventory management, vibe code an email MCP that can send payment links automatically, and unpack how environment setup, debugging, and tool orchestration get handled behind the scenes. *What you’ll learn:* 1. A practical, repeatable workflow for turning any working script or function into a custom MCP—and exposing it to natural-language control 2. How to transform messy CSVs into visualizations, HTML reports, and actionable business insights without needing a data science background 3. Ways to hook Goose into live business systems (e.g. Square inventory, payments) so analysis flows directly into operational action 4. The thinking behind Block’s decision to open-source Goose 5. Lessons from Block’s bottom-up meets top-down adoption model 6. Why organizational transformation, not just picking the right LLM, will separate AI winners from laggards over the next few years 7. How to scale an internal MCP catalog 8. The organizational transformation required to fully leverage AI capabilities *Brought to you by:* CodeRabbit—Cut code review time and bugs in half. Instantly: https://coderabbit.link/howiai Lenny’s List—Hands-on AI education curated by Lenny and Claire: https://maven.com/lenny *Where to find Jackie Brosamer:* LinkedIn: https://www.linkedin.com/in/jbrosamer/ *Where to find Brad Axen:* LinkedIn: https://www.linkedin.com/in/bradleyaxen/ *Where to find Claire Vo:* ChatPRD: https://www.chatprd.ai/ Website: https://clairevo.com/ LinkedIn: https://www.linkedin.com/in/clairevo/ X: https://x.com/clairevo *In this episode, we cover:* (00:00) Introduction to Goose and its data analysis capabilities (02:27) How Block embraced AI across the organization (04:48) What Goose is and why Block open-sourced it (07:45) Demo: Analyzing farm-stand sales data with Goose (12:18) Creating shareable HTML reports from data analysis (14:15) Model context protocols (MCPs) that Goose uses (18:56) Demo: Using Square MCP to create a product catalog (23:35) Creating payment links from analyzed data (26:30) Demo: Building a custom email MCP (31:18) Testing the new email MCP with Goose (36:09) Debugging and fixing MCP code errors (38:44) Connecting workflows: sending payment links via email (41:30) Lightning round and final thoughts *Tools referenced:* • Goose: https://block.github.io/goose/ • Pandas: https://pandas.pydata.org/ • Plotly: https://plotly.com/ • Python: https://www.python.org/ • ChatGPT: https://chat.openai.com/ • Claude: https://claude.ai/ • Cursor: https://www.cursor.com/ • Mailgun: https://www.mailgun.com/ *Other references:* • Block: https://block.com/ • Model context protocol (MCP): https://www.anthropic.com/news/model-context-protocol • GitHub: https://github.com/ _Production and marketing by https://penname.co/._ _For inquiries about sponsoring the podcast, email jordan@penname.co._

BABrad AxenguestCVClaire VohostJBJackie Brosamerguest

Jul 28, 2025·46m·Watch on YouTube ↗

📖 CHAPTERS

1. 1
   0:00 – 2:27

   Goose in one sentence: an agent that connects tools to solve real tasks

   The episode opens with a quick preview of Goose as a tool-agnostic AI agent that can read data and take actions in real systems. The hosts frame the core promise: connect capabilities (tools) and let the agent complete end-to-end workflows.

2. 2
   2:27 – 4:48

   How Block scaled AI adoption: bottoms-up demand meets leadership alignment

   Jackie explains Block’s fast AI adoption as a blend of grassroots experimentation and top-down support. A notable insight: sales teams were among the earliest and most eager adopters, alongside engineers.

3. 3
   4:48 – 7:45

   What Goose is—and why Block open-sourced it

   Brad defines Goose as an LLM-powered agent that uses a collection of tools to solve problems, designed to be model- and capability-agnostic. Jackie and Brad explain open-sourcing as both a company value and a way to accelerate ecosystem innovation and model flexibility.

4. 4
   7:45 – 12:18

   Demo setup: farm-stand sales CSV and what questions to ask the agent

   Jackie introduces a realistic example using farm-stand sales data in a CSV. She prompts Goose to use Python/Pandas to identify top revenue items, busiest days, and broader trends—plus recommendations, not just analysis output.

5. 5
   12:18 – 14:15

   Agentic data analysis in practice: environments, dependencies, and insights

   Goose runs the analysis locally, writing Python commands and even managing dependency issues by creating/fixing a virtual environment. The output includes ranked products, weekday patterns, and operational recommendations without additional prompting.

6. 6
   14:15 – 18:56

   Turning analysis into something shareable: auto-generated HTML reports

   Jackie shows how Goose can convert an analysis into a shareable HTML report with charts (e.g., Plotly). The discussion highlights how this helps non-technical users distribute insights quickly and build lightweight dashboards.

7. 7
   18:56 – 23:35

   MCP explained: the ‘arms and legs’ that let agents interact with the world

   Brad defines Model Context Protocol (MCP) as the standard way Goose connects to external systems via “servers” that expose tools and resources. MCP enables the agent to read data and take real actions in third-party/internal platforms.

8. 8
   23:35 – 26:30

   Demo: using the Square MCP to create a product catalog from a CSV

   Brad connects Goose to a Square MCP server and asks it to read the farm CSV and create items in a Square catalog. The key takeaway is automatic translation from messy input formats into correct API calls and structured objects in a real product.

9. 9
   26:30 – 31:18

   From catalog to revenue: generating real payment links from analyzed items

   With the catalog created, Brad asks Goose to generate a payment link (e.g., “three pumpkins”). Goose figures out required details such as location selection and produces a live, usable checkout link.

10. 10
    31:18 – 36:09

    Vibe coding an MCP: build the email tool by first proving a script works

    Brad shows his typical MCP-building workflow: start by writing a plain script (send a test email), then wrap it as an MCP tool. Goose generates a Mailgun-based Python script, while the team enforces basic security by denying the agent access to secrets (.env).

11. 11
    36:09 – 38:44

    Wrapping the script into an MCP server: SDK context, wiring, and debugging

    Because the model may not know the newest MCP SDK patterns, Brad provides reference code from the MCP Python SDK README. Goose generates the MCP server, they configure it for stdio, then iterate through errors until the MCP loads and tools become visible in Goose.

12. 12
    38:44 – 41:30

    Connecting workflows: email the payment link using the new MCP tool

    Brad enables the new email MCP in a separate conversation and demonstrates that Goose can use it immediately—without sharing prior coding context. The agent composes an email with the payment link and sends it successfully, completing the full loop from data to payment to outreach.

13. 13
    41:30 – 46:31

    Lightning round: favorite MCPs, adoption advice, and practical prompting habits

    The episode ends with quick personal preferences and tactical advice for getting value from AI tools. They emphasize automating disliked tasks, treating AI as an evolving learning surface, and restarting sessions when things go off-track.