Skip to main content
Glama

From Experiment to Enterprise: Scaling MCP at Block

Written by on .

Block
Agentic Ai
mcp
  1. Intuition: Beyond Code Generation
    1. Implementation: Company-Wide Agent Adoption
      1. Key Strategies
        1. Example: Internal OAuth-Based Server Auth
          1. Example: Dynamic MCP Server Activation
            1. Cross-Functional Enablement
              1. Notable Use Cases
                1. Example: Natural Language to SQL via Snowflake MCP
                2. Productization Features
                  1. Example: Recipe Schema
                  2. Final Thoughts
                  3. Acknowledgements

                    When Block reorganized its engineering teams into a unified structure, one challenge quickly emerged: streamlining tools and workflows across 12,000 employees. The initial goal was to build a dev-focused agent, but as adoption grew, a broader question arose—how can we make an MCP agent work for everyone, not just engineers?

                    Intuition: Beyond Code Generation

                    Bradley Axen, a principal ML engineer at Block, started with a prototype agent that did more than generate code—it executed real development tasks. Once OpenAI introduced tool-calling, this became viable, but building custom toolkits for every API proved unscalable. The solution? Adopt the MCP spec and rearchitect the agent, now known as Goose, as an MCP client.

                    Initially CLI-only, Goose was rebuilt with a desktop app, made LLM-agnostic, and integrated with multiple model providers like OpenAI, Anthropic, and Meta—hosted internally via Databricks. These early design choices, aimed at developers, turned out to be key enablers for company-wide usage.

                    Implementation: Company-Wide Agent Adoption

                    Key Strategies

                    • Default Distribution: Goose is auto-installed and auto-updated on every Block laptop.

                    • Pre-Bundled MCP Servers: Over 60 internal MCP servers built and bundled into Goose, removing the need for external installs.

                    • Safe Execution: An internal allow-list blocks unauthorized MCP servers.

                    • Smart Context Handling:

                      • Dynamically enables only relevant MCP servers.
                      • Adds a summarizer for long sessions.
                      • Visual context progress bar warns of context window limits.

                    • Secure Auth:

                      • All internal servers use SSO-based OAuth.
                      • Prompts users with familiar browser flows—no manual API keys.

                    Example: Internal OAuth-Based Server Auth

                    # Python (simplified) @app.route("/auth/callback") def handle_oauth_callback(): token = exchange_code_for_token(request.args["code"]) user = get_user_info(token) if user.is_block_employee(): store_token(user.id, token) return redirect("/dashboard") else: return "Unauthorized", 403

                    Example: Dynamic MCP Server Activation

                    const activeServers = determineRelevantServers(userPrompt); const contextWindow = calculateContextUsage(activeServers); if (contextWindow.isNearLimit()) { summarizeContext(); } activateOnly(activeServers);

                    Cross-Functional Enablement

                    • Slack Culture: Two channels—one for help, one for inspiration—drove viral adoption.
                    • Internal Education: Weekly brown-bags, tailored DevRel workshops, and prompting 101 sessions made AI approachable.
                    • Hack Week Catalyst: Accelerated MCP server development by cross-team volunteers.

                    Notable Use Cases

                    • Snowflake MCP: Natural language queries for sales and fraud detection.
                    • Databricks MCP: Optimized sales lead distribution in minutes vs. days.
                    • PagerDuty MCP: Identified and eliminated recurring incident triggers.
                    • Glean MCP: Surfaced internal tribal knowledge on demand.

                    Example: Natural Language to SQL via Snowflake MCP

                    # Prompt from Goose "Show me transactions flagged as suspicious in the last 7 days" # Behind the scenes query = "SELECT * FROM transactions WHERE flagged = true AND date > CURRENT_DATE - 7" results = snowflake.execute(query)

                    Productization Features

                    • Recipes: Package up goals, tools, and interactions into shareable mini-agents.
                    • Web App Deployer: Empowers non-engineers to launch internal tools without IT support.

                    Example: Recipe Schema

                    { "title": "Weekly Sales Report Generator", "servers": ["Snowflake", "GoogleSheets"], "steps": [ {"action": "query", "server": "Snowflake", "params": {"table": "sales", "filter": "last_7_days"}}, {"action": "write", "server": "GoogleSheets", "params": {"sheet_id": "abc123"}} ] }

                    Final Thoughts

                    Block's journey illustrates that with smart defaults, proactive infrastructure, and human-centered education, MCP can power not just engineering tools but enterprise transformation. Goose is no longer just an internal agent—it’s a blueprint for inclusive agent deployment at scale.

                    Acknowledgements

                    This guide is based on Angie Jones's insightful talk at the "From Experiment to Enterprise" session at the MCP Developer Summit, where she shared how Block scaled the Goose agent from a developer tool into a company-wide platform across 15+ job functions.

                    Special thanks to the Anthropic team and the broader MCP developer community for fostering the standards and ecosystem that make enterprise-scale adoption possible.

                    Written by Om-Shree-0709 (@Om-Shree-0709)