How I AIHow Block’s custom AI agent supercharges every team, from sales to data to engineering
CHAPTERS
- 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.
- •Goose is positioned as an “AI agent” that becomes useful via connected tools
- •Early teaser: take a CSV and create items in a Square dashboard automatically
- •Goal of the episode: show both “vibe data analysis” and “vibe coding” with MCP
- •Focus on practical, repeatable workflows rather than one-off prompts
- 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.
- •Bottoms-up experimentation surged after ChatGPT (sales + engineering pockets)
- •Leadership reinforced and standardized emerging practices across groups
- •Organizational transformation is harder than tech change (humans don’t scale exponentially)
- •Non-developers often show surprising creativity in stitching tools together
- 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.
- •Goose = LLM + tools that execute workflows (not just chat)
- •Designed to be agnostic: connect capabilities and it “just solves” tasks
- •Open-source as a value + a strategy to learn from global patterns and contributions
- •Model flexibility: avoid being locked into a single vendor/model as models evolve
- 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.
- •Input data: date, item, quantity, price (messy CSV realism)
- •Prompt design: ask for metrics (top items, busy days) and “trends + recommendations”
- •Goose searches locally for the CSV (ripgrep) before analyzing
- •Emphasis on iterative workflow: start broad, then drill deeper (e.g., elasticity, regression)
- 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.
- •Local execution with tool calls: Goose writes/executes Python + Pandas analysis
- •Handles environment pitfalls (missing packages, virtualenv setup) as part of the workflow
- •Findings: top revenue items (berries), busiest day patterns, average order value insights
- •Agent proactively generates actionable recommendations (pricing, staffing, inventory focus)
- 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.
- •Goose generates a local HTML report with visualizations (bar charts, summaries)
- •Business users often prefer shareable webpages over raw notebooks/spreadsheets
- •Reports can be refined iteratively (design, layout, additional charts)
- •Internal option discussed: publish static pages privately within the company via MCP
- 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.
- •MCP server = bundle of tools (and sometimes resources) exposed to the agent
- •MCP is how the model safely performs real-world operations (APIs, systems)
- •Goose ships with a small default set; Block runs many more internally
- •Examples mentioned: Google Drive, internal data MCP, publishing websites, CLI/dev tools, computer controller
- 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.
- •Square MCP used to create catalog items in an empty Square account
- •Agent reads the CSV and maps entries into Square’s catalog structure
- •MCP design pattern: discoverability methods (look up available catalog operations) to manage tool overload
- •Broader implication: “import” flows can accept arbitrary formats (CSV/PDF/image menu) and let the agent normalize
- 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.
- •Agent creates a real payment link tied to the newly created catalog items
- •Handles required configuration steps (e.g., selecting a selling location) autonomously
- •Demonstrates end-to-end workflow value: data → catalog → checkout link
- •Highlights background-task mode: hand it work, walk away, return to completed result
- 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).
- •Workflow pattern: implement core capability first (script), then MCP wrapper
- •Mailgun chosen; API key stored in .env; agent is blocked from reading secrets directly
- •Goose writes the code + resolves environment setup details
- •Time savings: avoids docs spelunking and boilerplate for unfamiliar APIs
- 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.
- •Provide minimal SDK example context to bootstrap correct MCP server structure
- •Switch to stdio MCP for local integration with Goose
- •Configure Goose extension with correct Python path + server command
- •Iterative debugging: paste errors back to Goose, fix, retry until tool registers
- 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.
- •Tool availability is decoupled from conversation memory: toggle MCP on and use it anywhere
- •Agent composes email content + embeds the payment link automatically
- •Demonstrates composability: Square MCP output becomes Email MCP input
- •End-to-end automation: analysis → catalog → payment link → email delivery
- 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.
- •Favorite MCPs: Jackie—Google Drive; Brad—Shell (command arguments recall)
- •Adoption tip: automate toil first (unit tests, busywork, repetitive ops)
- •Mindset: models are the worst they’ll ever be—learn by observing failures and wins
- •Tactics: restart sessions when stuck; use style keywords; summarize-good/omit-bad to reboot prompts
