Preface¶

In February 2026, Stripe’s Engineering Blog published two in-depth articles about Minions, marking the first systematic disclosure of the deployment scale and architectural details of its self-developed coding Agent. According to official data, Minions now merges over 1,300 Pull Requests every week — all PRs are fully handled by the Agent from instruction to commit, with zero manually written code, only requiring engineer review before being merged into the main branch.

This figure is quite notable in the enterprise-grade unattended coding agent space. Unlike “human-AI pairing” tools such as Cursor and Claude Code, Minions is designed for fully unattended operation: engineers send a message on Slack, and the Agent independently completes implementation, linting, testing, and branch pushing in an isolated environment, ultimately producing a PR that passes CI checks. This article organizes the key architectural points of Minions and its implications for developer productivity, based on Stripe’s official blog and public case materials.

What is Minions¶

Minions is Stripe’s self-developed end-to-end coding Agent, with the following core characteristics:

1. Fully Unattended: No human intervention is required during operation, and human-AI collaboration features such as “interruption” or “mid-task handover” are not supported.
2. One-shot Task-oriented: Aims to complete tasks in one go, seamlessly going from natural language instructions to a reviewable PR.
3. Zero Manual Coding: 100% of the code in PRs merged into the main branch is generated by the Agent; human roles are limited to review and merge decisions.
4. Deep Integration with Existing Dev Toolchains: Reuses infrastructure such as Devbox, CI, linting, and MCP tools that Stripe engineers use daily.

Typical use cases include: initiating fixes by @-mentioning Minions in a Slack thread, one-click triggering of flaky test fixes from internal tickets, and launching multiple Minions in parallel to handle small issues during on-call shifts. Stripe engineers can still use Cursor and Claude Code for planning and pair programming at the same time; Minions is responsible for parallelizable independent tasks to free up the most scarce resource — developer attention.

Why Stripe Chose to Build It In-House¶

The scale and constraints of Stripe’s codebase make it impossible to directly adopt general-purpose coding agents:

• The total code volume reaches hundreds of millions of lines, distributed across a small number of extremely large monorepos.
• The main backend stack is Ruby (non-Rails) + Sorbet type system, a relatively niche combination for LLMs.
• A large number of Stripe’s self-developed libraries are used, with limited corresponding context in model training data.
• The code handles over one trillion US dollars in annual payment transaction volume, with extremely strict compliance and regulatory constraints.

Stripe’s blog points out that LLM Agents perform excellently when “building prototypes from scratch”, but the difficulty skyrockets when iterating on large-scale, mature, highly constrained legacy codebases. Human engineers need to build complex mental models to make effective changes; similarly, Agents need to obtain the correct tools and intuition within a limited context window.

Over the years, Stripe has continuously invested in developer productivity infrastructure across source code management, development environments, code generation, CI, and other areas. Minions’ harness is tightly coupled with this infrastructure — “what works well for humans also works well for LLMs” became one of its core design principles. This is also why the team chose to fork the open-source Block project Goose and deeply customize it, rather than directly purchasing off-the-shelf SaaS solutions.

Core Architecture: Devbox + Goose Harness + MCP¶

1. Devbox: Isolated Development Environment with 10-Second Warm-Up¶

Minions runs on Devbox, which Stripe engineers use daily — essentially AWS EC2 instances pre-installed with source code, development services, and remote IDE connectivity. Key design points:

• Hot Pool: Actively maintains a pool of Devbox instances that have already cloned giant Git repos, pre-warmed Bazel and type checking caches, and started code generation services, allowing new instances to be ready in approximately 10 seconds.
• Task-Level Isolation: Engineers often run multiple Devbox instances simultaneously (for example, six or seven parallel tasks), with each Minion occupying an independent environment, avoiding issues like git worktree that do not scale well at Stripe’s scale.
• Security Boundary: Devbox is located in the QA environment, isolated from production resources, real user data, and arbitrary public network egress; the Agent can skip confirmation prompts and obtain full Shell permissions within the Devbox, with the blast radius limited to a single machine.

Devbox was originally designed for human developers, but its parallelism, predictability, and isolation happen to make it a natural runtime carrier for LLM Agents.

2. Goose Harness: Custom Orchestration Based on Open-Source Agent¶

In late 2024, Stripe internally forked Block’s Goose — one of the earlier and widely adopted coding Agent frameworks in the industry — and has continuously modified it for the Minions scenario. Unlike supervised tools like Cursor and Claude Code where “humans watch from the side”, the Minions harness is specifically optimized for unsupervised operation:

• Removed human interaction features such as relying on manual interruption or manual trigger instructions.
• Granted the Agent full permissions in the isolated Devbox, without requiring step-by-step confirmation.
• Interleaves the Agent loop with deterministic code (Git operations, linting, test pushes, etc.), balancing LLM flexibility and process reliability.

3. MCP and Toolshed: Shared Capability Layer with 400+ Tools¶

Minions calls networked LLM functions through the Model Context Protocol (MCP). Stripe internally built a centralized MCP server called Toolshed that hosts nearly 500 tools covering internal systems and common SaaS platforms, shared across the company’s entire fleet of Agents including Minions, Cursor, and Slack Bot.

Minions only accesses a carefully selected subset of tools by default (the “smaller box” strategy), and engineers can expand it by theme. Before runtime starts, the system also deterministically pre-runs MCP tools to pre-populate context for links in user messages — for example, internal documentation, ticket details, build status, Sourcegraph code search, etc.

Blueprint: Hybrid Orchestration of Workflows and Agents¶

Minions’ orchestration uses Stripe’s self-developed Blueprint primitive, sitting between fixed workflows and pure Agent loops:

• Deterministic Nodes (rectangular): Such as “Run configured Lint” and “Push changes”, execute code directly without calling the LLM.
• Agent Nodes (cloud-shaped): Such as “Implement task” and “Fix CI failures”, where the LLM makes autonomous decisions and calls tools.

Blueprints are defined in code in the form of a state machine, ensuring that critical steps (linting, pushing, etc.) are always executed, while delegating open sub-tasks to the Agent. Stripe’s experience shows that writing deterministic logic for predictable small decisions saves Token and CI costs and reduces the probability of errors from the Agent “acting freely”. Teams can also write custom Blueprints, for example, to handle complex LLM-assisted migrations that cannot be done with purely deterministic codemods.

Full End-to-End Link from Slack to PR¶

A typical Minions run roughly goes through the following stages:

1. Trigger: An engineer initiates a task on Slack @-mentioning the app, internal documentation platform, Feature Flag platform, or ticket UI; the Slack thread content and links are automatically used as context.
2. Environment Ready: A Devbox is allocated from the hot pool, and the latest master checkout is obtained within approximately 10 seconds.
3. Context Collection: Conditional Agent rule files (compatible with formats like Cursor Rules) are mounted by directory; MCP tools are pre-run to hydrate dynamic information.
4. Blueprint Execution: The Agent node implements the task; deterministic nodes run linting, formatting, and other steps.
5. Local Feedback: Pre-push hooks and background daemons automatically fix common lint issues before pushing, usually completing within a few seconds.
6. CI Iteration: After pushing, relevant subsets of Stripe’s 3 million+ test suite are triggered; failures with autofix capabilities are automatically applied, otherwise the Agent is notified to fix them. A maximum of two CI cycles are run to balance speed and completeness.
7. PR Delivery: A branch is created, pushed, and a Pull Request is generated following Stripe’s PR template, notifying engineers for review.

If the PR is not fully correct, engineers can continue sending additional instructions to Minions to update the branch, or manually edit its output — the north star is still zero manual coding, but partially correct output is already a good starting point.

CI/CD Integration and “Shift Left Feedback”¶

Minions’ success is inseparable from Stripe’s existing CI/CD and testing infrastructure:

Stripe emphasizes “Shift feedback left”: any checks that would fail in CI should be presented as early as possible in the IDE or git push stage. Minions shares the same feedback mechanism as human engineers, which is an important prerequisite for keeping 1,300+ weekly PRs still manageable for review.

Implications for Developer Productivity¶

The Minions case conveys several generalizable lessons:

1. DX Investment is AX Investment: Documentation, Devbox, MCP tools, linting pipelines — infrastructure built for humans also benefits Agents; conversely,完善的 MCP and observability for Agents also improves human efficiency.
2. Isolated Environment is a Prerequisite for Unattended Agents: 10-second Devbox warm-up + QA isolation makes “full permissions, no confirmation” feasible in enterprise scenarios.
3. Orchestration Needs Mixed Deterministic Steps: Pure Agent loops are costly and unstable on ultra-large-scale codebases; Blueprint-style “boxing in the LLM” improves system-level reliability.
4. MCP as the Agent Tool Bus: The Toolshed model shows that enterprises need a centrally governed, Agent-type curated tool layer, rather than each Agent connecting to internal APIs independently.
5. Bottlenecks Shift Rather Than Disappear: After coding automation, review capacity, high-quality requirement supply, release and observability may become new bottlenecks; robust CI and blue-green deployments are a safety net for trusting AI-generated output.

Third-party case libraries such as ZenML also mention Stripe’s exploration in the Machine-to-Machine Payment direction — where Agents act as economic entities to independently purchase third-party API services — which belongs to a different product line than Minions, but both point to the evolution of Agents from “auxiliary tools” to “autonomous executors”.

Summary¶

Stripe Minions is currently one of the largest-scale and most complete architectural enterprise-grade unattended coding agent practices publicly disclosed: 1,300+ zero-manual-coding PRs per week, 10-second Devbox warm-up, Goose fork + Blueprint orchestration, Toolshed MCP tool layer, and a feedback loop with a maximum of two CI cycles, forming a reusable reference paradigm.

For teams evaluating Agent-based coding adoption, the signal from Minions is clear — this is not an effect achievable by just swapping in a Copilot plugin, but a systems engineering effort involving dev environments, testing infrastructure, tool protocols, and orchestration primitives. Part 1 focuses on user experience, and Part 2 focuses on implementation details, both available on the Stripe Engineering Blog.