How I AIHow Block’s custom AI agent supercharges every team, from sales to data to engineering
CHAPTERS
- 0:00 – 2:31
Goose in action: from raw CSV to Square catalog (teaser)
A quick cold open shows Goose acting as an LLM-powered agent that can read a CSV and take real-world actions—like creating items directly in a Square dashboard. The hosts highlight how little manual formatting is required to turn “messy” data into a working product catalog.
- •Goose is designed as a tool-agnostic AI agent
- •CSV is used as input to create Square catalog items
- •Emphasis on “connect capabilities → solve problem” workflow
- •Sets up the episode’s themes: data analysis + MCP-based automation
- 2:31 – 3:34
Block’s AI adoption: bottoms-up demand meets leadership support
Claire asks how Block embraced AI broadly and quickly. Jackie explains it was driven both by grassroots usage (especially sales and engineers) and leadership standardizing best practices across teams.
- •Bottoms-up adoption accelerated after ChatGPT’s release
- •Sales teams pushed hard for AI to help with leads and productivity
- •Engineering adoption grew as coding assistants improved
- •Leadership worked to scale practices consistently across groups
- 3:34 – 4:49
AI transformation is organizational, not just technical
The conversation shifts from tools to transformation: technology can scale exponentially, but organizations and humans don’t. Jackie frames AI success as an organizational change challenge—culture, operations, and enabling people closest to problems.
- •Organizational transformation is the key competitive differentiator
- •Culture/operations are often harder than the tech itself
- •Non-developers can be uniquely creative in tool “composition”
- •Value comes from empowering domain experts, not only engineers
- 4:49 – 6:21
What Goose is: an extensible AI agent powered by tools + MCP
Brad defines Goose as an LLM-driven agent that solves tasks by invoking tools. They open-sourced it to maximize extensibility, letting anyone connect new capabilities via MCP and tailor workflows to their environment.
- •Goose = LLM + a collection of tools to complete tasks
- •Designed to be capability-agnostic and extensible
- •Open-source enables broader experimentation and contributions
- •MCP is the key mechanism for connecting Goose to systems
- 6:21 – 7:46
Why open-source: ecosystem learning + model flexibility
Jackie explains Block’s open-source values and the practical benefits of an open ecosystem: faster pattern discovery and broader innovation. Open source also helps Goose stay model-flexible as new models excel at different tasks.
- •Open source aligns with Block’s company values
- •Ecosystem contributions reveal emerging patterns faster
- •MCP server ecosystem has grown rapidly in months
- •Goose aims to work with many models (coding vs writing vs reasoning)
- 7:46 – 12:21
Demo: ‘vibe data analysis’ on farm-stand sales with Python/Pandas
Using a realistic (but safe) farm-stand dataset, Jackie has Goose locate the CSV, set up Python dependencies, and run analysis with Pandas. Goose outputs revenue drivers, busiest days, and additional trends without heavy manual work.
- •Goose finds data locally (ripgrep) and runs analysis via shell/Python
- •Handles environment setup (virtualenv) and dependency issues
- •Computes top revenue items and day-of-week patterns
- •Generates extra insights and operational recommendations automatically
- 12:21 – 14:25
Turning analysis into shareable dashboards: local HTML + internal publishing
Rather than sharing raw logs or notebooks, Jackie shows Goose generating a simple HTML report with charts (e.g., Plotly). They discuss internal workflows where an MCP can publish static sites to share across the company.
- •Business users prefer shareable web pages over raw analysis output
- •Goose can generate local HTML reports with visualizations
- •Block uses an internal publishing MCP (“Block Cell”) to share URLs
- •Goose runs locally, appealing to users who want end-to-end control
- 14:25 – 18:59
MCPs explained: the ‘arms and legs’ that let agents act in the real world
Brad gives a practical definition of MCP (Model Context Protocol): servers expose tools and resources that an agent can call. This is how Goose connects to third-party systems and performs actions, not just text generation.
- •MCP servers expose collections of tools to the agent
- •They can also provide data/resources (context) to the model
- •MCP enables real-world interactions (APIs, systems, workflows)
- •Goose includes bundled MCPs; Block runs many more internally
- 18:59 – 24:29
Demo: Using the Square MCP to create a product catalog from messy input
Brad enables a real Square MCP and shows Goose translating the farm CSV into API calls that create catalog categories and items. The demo highlights how this approach avoids brittle “import format” requirements typical in product UX.
- •Square MCP provides discoverable operations (catalog methods, etc.)
- •Goose reads the CSV and maps it into Square’s catalog objects
- •Avoids strict column naming/format requirements in traditional imports
- •Demonstrates multimodal potential (could import from image/PDF/menu)
- 24:29 – 26:39
From catalog to revenue: generating real payment links automatically
With items now in Square, Brad asks Goose to create a payment link for a specific order (e.g., three pumpkins). Goose handles necessary details (like location selection), producing a working checkout link end-to-end.
- •Goose creates a payment link tied to real Square items/prices
- •Agent autonomously resolves required parameters (e.g., location)
- •Highlights ‘hand it a task, walk away, come back done’ workflow
- •Demonstrates practical, on-the-go commerce automation potential
- 26:39 – 36:02
Vibe coding an email MCP: scaffold → send email → wrap as MCP tool
Brad builds a new MCP server that can send emails via Mailgun. He demonstrates a pragmatic flow: first make a plain Python script work, then convert it into an MCP tool using the SDK example and minimal manual edits.
- •Start by proving core functionality (send a test email) before MCP-ifying
- •Security guardrails: deny agent access to secrets in .env
- •LLM writes integration code even when the developer doesn’t know the API
- •MCP SDK reference code is pasted in to compensate for model recency gaps
- 36:02 – 42:21
Debugging, testing, and chaining workflows: email the payment link
The new MCP hits code errors; Brad pastes error output back to Goose, which fixes issues iteratively. Finally, they enable the email tool in the original payment-link conversation and send the checkout link via email, completing a connected workflow.
- •Iterative debugging: paste errors, let the agent attempt fixes first
- •Practical tip: restart sessions when a thread goes off the rails
- •Tool verification: confirm Goose sees the new tool and can execute it
- •End-to-end workflow: create payment link → send it via email from the agent
- 42:21 – 46:31
Lightning round: favorite MCPs, adoption advice, and where to find Goose
They close with quick preferences (Google Drive, Shell), advice for hesitant adopters, and practical prompting tactics. The episode ends with links to Goose resources and Block’s open-source community channels.
- •Favorite tools: Google Drive (manager workflow) and Shell (command recall)
- •Adoption tip: automate the tasks you dislike (remove toil)
- •Learning mindset: models are the worst they’ll ever be—experiment and observe failures
- •Resources: block.github.io/goose, GitHub repo, Block Open Source Discord
