The pull requests keep coming. More than 1,300 of them each week, threading through Stripe's code review system with the steady rhythm of an assembly line. Only these days, a curious thing happens when engineers click through to examine the changes: no human actually wrote the code.
Stripe calls them "Minions"—a name that undersells what may be one of the most aggressive deployments of autonomous AI in software engineering to date. Since mid-September 2025, these AI agents have been quietly rewriting chunks of the payments giant's codebase, filing bug fixes, updating documentation, and chipping away at technical debt while the company's flesh-and-blood engineers focus on harder problems. By February 2026, when Stripe finally disclosed the system in a pair of blog posts, Minions were already responsible for more than 10% of all code contributions company-wide.
That's not a pilot. It's not a carefully managed demonstration for the press. It represents a fundamental recalibration of what unattended artificial intelligence can accomplish inside a production engineering environment where billions of dollars flow through the infrastructure daily.
The Mechanics of Letting Go
The architecture won't win awards for cleverness, which may be precisely why it works. Minions are what engineers call "one-shot agents." An engineer types a task into Slack, hits send, and walks away. The system spins up an isolated development environment—what Stripe calls a "devbox"—writes the code, runs the linter, executes the test suite, pushes a Git branch, and opens a pull request that, more often than not, passes continuous integration on the first try.
No conversation. No iteration. No human hand-holding. Either it works or it fails cleanly, logging the error and moving on.
Every pull request still requires human review before merging. Stripe has been emphatic about maintaining that guardrail, though one wonders how long that holds as the volume climbs. But the agent handles everything else: parsing the task, navigating a sprawling codebase, fixing lint errors, satisfying CI checks. What used to consume 20 minutes of an engineer's attention now happens in the background, unattended.
The foundation is a fork of Goose, an open-source agent framework from Block that's designed to be LLM-agnostic and run locally with access to developer tools. Stripe's version goes deeper, integrating tightly with internal infrastructure through a custom Model Context Protocol server the company named "Toolshed." That server exposes more than 400 internal tools—code search, documentation indexes, CI status dashboards, ticket systems, feature flag metadata—though not all at once. Stripe has carefully tuned which tools are visible for which types of tasks, and the system limits how many times an agent can retry failed CI checks to prevent runaway loops and cost overruns.
The design is deterministic where possible. Linting, testing, Git operations all follow fixed paths. The large language model does the reasoning, yes, but the harness keeps it from wandering too far off course.
What the Machines Actually Do
In practice, Minions cluster around a particular species of engineering work: the tedious but necessary. Documentation updates that have languished in backlog purgatory. Small UI tweaks that never quite justified blocking off calendar time. Bug fixes with clear reproduction steps. Technical debt that's been aging on a shelf because, well, who really wants to spend an afternoon renaming variables or removing deprecated API calls?
One Stripe engineer mentioned in internal posts that teams often spin up multiple Minions in parallel during on-call rotations, farming out a handful of small issues while they tackle something genuinely complex. The multiplication factor matters—these aren't simply one-for-one replacements of human effort.
More surprisingly, perhaps: product managers have started using the system themselves. Oliver Wang, a PM at Stripe, wrote that Minions let non-engineers self-serve on minor updates that previously required developer handoffs. That shift in leverage extends beyond raw code output into something more fundamental about how work flows through the organization.
Stripe has embedded Minion triggers directly into internal tools, including the company's Jira equivalent and feature flag management system. The philosophy, judging from employee commentary, is to surface tractable work wherever it lives and reduce the friction that allows technical debt to accumulate unnoticed. If a feature flag can be safely removed, a Minion files the PR. If a deprecated API has clear migration documentation, a Minion handles the migration for low-risk call sites.
Whether any of this actually ships faster is less clear—Stripe hasn't published cycle time data.
The Gaps in the Story
Stripe has disclosed less than it might. The company hasn't revealed which large language model powers Minions. Goose supports multiple providers—Anthropic, OpenAI, others—so Stripe could be using any of them, or even routing different tasks to different models based on complexity or cost. There's no public data on success rates, no average cost per pull request, no breakdown of which types of tasks fail most often.
The security posture remains vague beyond isolation and mandatory human review. The devbox model suggests strict boundaries, but the specifics of credential management, access control, and audit logging are internal matters Stripe hasn't chosen to illuminate.
This also isn't a product. Minions is purely an internal tool, built for Stripe's specific codebase, workflows, and engineering culture. The blog posts read more like a case study than a launch announcement. Other companies have access to the same open-source foundation in Goose, but replicating these results means replicating the integration work: the tooling, the orchestration, the organizational buy-in, the months of tuning that Stripe glossed over in a few paragraphs.
The timing carries weight. Stripe has been increasingly vocal about agent-based systems, including its Agent Toolkit SDK that allows AI agents to handle payments and billing for merchants, and the Agentic Commerce initiative launched alongside OpenAI. Minions operates separately from those commercial efforts, but the through-line is consistent: Stripe is wagering heavily that autonomous agents will reshape both software development and digital commerce. Internal deployment builds credibility for external products, intentionally or not.
What It Actually Means
The most striking aspect of Minions isn't the technology, which borrows liberally from open-source tools. It's the sheer volume. More than a thousand pull requests each week, reviewed by humans but written by machines, flowing into production at a company where code quality is an existential concern. Stripe processes hundreds of billions of dollars in payment volume annually. The margin for error is thin. And yet the company is comfortable letting agents author more than 10% of its code commits.
That implies the work isn't trivial. Throwaway scripts don't require pull requests and code review. The contributions have to be substantive enough, useful enough, and reliable enough to justify the review overhead. And Stripe's engineers aren't just tolerating these agent-written changes—they're actively spinning up multiple Minions in parallel to clear through on-call queues faster.
The one-shot constraint deserves more attention than it typically receives. Most AI coding assistants are conversational by design, waiting for feedback, iterating through multiple rounds, requiring constant human guidance. Minions completes tasks end-to-end or abandons them. That design choice forces clarity in task definition and naturally limits scope to genuinely automatable work. It also makes the system composable in ways that conversational assistants aren't—engineers can launch several Minions simultaneously because each operates independently.
Whether this pattern generalizes beyond Stripe remains uncertain. The company maintains a highly structured monorepo, mature internal tooling, and a codebase large enough that even small percentage gains in productivity compound meaningfully. Smaller teams might lack the infrastructure to make unattended agents viable. Larger, less disciplined codebases might not have sufficient test coverage or consistent linting to prevent agents from merging broken changes past distracted reviewers.
But the data point is real. Stripe is shipping upward of 1,300 agent-authored, human-reviewed pull requests weekly. The system launched five months ago and continues running. That's not a demonstration. That's production infrastructure, quietly rewriting the boundaries of what software development looks like when the machines start carrying more of the load.
And perhaps more than the founders expected when they named them "Minions," these autonomous workers are beginning to look less like assistants and more like colleagues.
