Why Big Companies Are Building Their Own Coding Agents
There's a strange thing happening at companies that can afford the best off-the-shelf tools money can buy. Ramp built its own background coding agent, Inspect. Stripe built Minions. Block built and open-sourced goose. These are companies with the budget to hand every engineer a Cursor seat and a Claude Code license tomorrow. Instead they're staffing teams to build agents in-house.
The obvious read is "not-invented-here syndrome at well-funded companies." I think that's wrong. When three serious engineering orgs independently make the same expensive build-vs-buy call, the interesting question isn't why are they wasting money — it's what do they all see that the generic tools can't give them?
The answer comes down to three words: context, integration, and ownership. And the payoff is real enough that it's worth understanding, because it tells you where the actual moat in AI engineering is forming.
The thing a generic agent can't have: your context
A coding agent is only as good as what it knows about your system. Off-the-shelf agents are extraordinary at the general case — they've read more open-source code than any human ever will. What they haven't read is your internal RPC framework, your feature-flag service, your seventeen years of architectural decisions, or the proprietary library that three people understand and zero people documented.
Stripe makes this concrete. Their codebase is hundreds of millions of lines, mostly Ruby with Sorbet typing, full of in-house libraries no foundation model has ever seen. On top of that it's code that "moves well over $1 trillion per year of payment volume live in production" — the kind of regulatory and compliance constraints that don't fit in a context window and don't tolerate a plausible-looking guess. A generic agent walks into that cold. Stripe's agent walks in pre-loaded.
Ramp frames the same idea more ambitiously. The goal for Inspect was an agent "never limited by missing context or tools, but only by model intelligence itself." Read that again — it's a design philosophy. Take everything that isn't raw model capability off the table as a constraint. Give the agent the entire codebase, every internal service (Postgres, Redis, Temporal), every observability tool (Sentry, Datadog, LaunchDarkly), every developer integration (GitHub, Slack, Buildkite) — so that the only ceiling left is how smart the model is. That's what Ramp means by a "full-context" agent.
You can buy model intelligence. You cannot buy context about your own system — you have to wire it in yourself.Integration is the product, not a feature
Here's the part that surprised me. For all three companies, the agent's reasoning loop is almost an afterthought next to the plumbing around it.
Stripe's agents run on "devboxes" — pre-warmed developer machines that spin up in ten seconds with code and services already loaded. They connect to a central MCP server they call "Toolshed," hosting more than 400 MCP tools spanning internal systems and SaaS platforms, plus Sourcegraph for code intelligence. The agent itself is a fork of Block's goose. The agent was the easy part to acquire; the 400 tools were the moat.
Ramp's Inspect runs each session in a Modal sandbox that mirrors a real engineer's full-stack environment — VS Code server, a web terminal, a VNC stack with Chromium so the agent can visually verify its own UI changes. A cron job rebuilds repository snapshots every 30 minutes, so a session starts working within seconds against code that's at most half an hour stale. None of that is "AI." All of it is what makes the AI useful.
This is the same pattern I keep coming back to with MCP, skills, and workflows: the model is the commodity, and the context and tool layer wrapped around it is where the engineering — and the differentiation — actually lives. These companies didn't build agents. They built the integration surface their agents plug into, and the agent is the cheap, swappable part.
It's also why Stripe's guiding principle is so good: "if it's good for humans, it's good for LLMs, too." Minions consume the same source control, the same CI, the same agent rule files their human engineers use. The investment in developer experience they'd already made became the investment in agent experience. Build one surface, serve both.
Ownership: where it runs, and what it's allowed to do
The third reason is the least glamorous and maybe the most important: control.
When your agent runs inside a vendor's product, you live inside the vendor's decisions — where the code executes, which model it calls, what data leaves your network, how it's allowed to integrate. For a fintech moving a trillion dollars or a card company holding everyone's transaction data, "the code is executing in someone else's cloud" is not a footnote. Owning the stack means the agent runs on your isolated infrastructure, touches your internal services directly, and obeys your compliance boundaries by construction.
Block took ownership to its logical end and open-sourced goose under Apache 2.0 — built on MCP, LLM-agnostic (bring whichever model you want), extensible by anyone. CTO Dhanji Prasanna's framing was that the point is to "reduce toil and give people time back to be their most creative selves." And then the open-source bet paid off in the most validating way possible: Stripe forked goose to build Minions. One company's owned-and-shared tool became another company's foundation. That's the open-source flywheel working exactly as intended.
My takeaway: "Build vs. buy" is the wrong frame here. It's really "rent the intelligence, own the integration." Nobody is training their own frontier model — they're all calling someone else's. What they refuse to rent is the layer that touches their proprietary context and their production systems. That's the line in the sand, and it's a sensible place to draw it.
The results are not subtle
It would be easy to file this under "big companies doing expensive R&D theater." The adoption numbers say otherwise.
- Ramp: Inspect writes somewhere between a third and over half of all pull requests merged to its frontend and backend repos, depending on which writeup you read and when — and over 80% of Inspect's own codebase is now written by Inspect. The tool builds itself.
- Stripe: Minions produce over a thousand merged pull requests every week — all agent-written, all human-reviewed before merge.
- Block: goose is in production internally and now a widely adopted open-source project, with Stripe's fork as the highest-profile proof it generalizes.
The Stripe workflow is worth picturing because it shows what "one-shot end-to-end" really means: a run "begins with a Slack message and concludes with a pull request passing CI, ready for review — with no interaction in between." You describe the task, walk away, and come back to a reviewable PR. Engineers fire off several in parallel during an on-call rotation to clear a backlog of small issues at once.
This is the compute-budget era showing up in the engineering org specifically: the human stops typing the code and starts orchestrating a fleet of agents that type it, then spends their judgment on review and direction. It's also the most literal version of AI starting to build itself — Inspect writing 80% of Inspect is recursive self-improvement you can watch in a PR feed.
What this means if you're not Ramp or Stripe
You are (probably) not going to build a 400-tool MCP server this quarter. So is the lesson just "admire the giants"? No — there are three transferable takeaways, and they scale down.
1. The agent is the commodity; your context is the asset. When you adopt an off-the-shelf tool, the highest-leverage work isn't picking the tool — it's feeding it your context. Good CLAUDE.md/rules files, an MCP server or two pointed at your internal docs and systems, clean and discoverable tooling. That's the part that's yours, and it's the part that compounds.
2. Invest in the integration surface, and you serve humans and agents at once. Stripe's "if it's good for humans, it's good for LLMs" cuts both ways. Every painful manual step you remove for your engineers — a flaky setup script, an undocumented service, a slow CI loop — is also a step you've removed for any agent you eventually point at the codebase. DX is agent-readiness, bought early.
3. Watch the ownership line. You don't need to fork goose. But you should know which parts of your stack you're comfortable renting and which you're not — where your proprietary context and production systems are, and what's allowed to touch them. That decision is the same one Ramp and Stripe made; you're just making it at a smaller scale.
Frequently Asked Questions
Why would a company build its own coding agent when tools like Cursor and Claude Code exist?
For three reasons: context (off-the-shelf agents don't know your internal codebase, proprietary libraries, or compliance constraints), integration (the real work is wiring the agent into your services, CI, source control, and observability — Stripe's agent connects to 400+ internal tools), and ownership (running the agent on your own infrastructure matters when you handle sensitive data or money in production). They're not training their own models — they're owning the integration layer around someone else's model.
What are Inspect, Minions, and goose?
Inspect is Ramp's background coding agent, running on Modal sandboxes with full access to Ramp's codebase and internal services; it writes a third to half of Ramp's merged PRs. Minions are Stripe's unattended, one-shot agents that take a task from a Slack message to a CI-passing PR with no interaction in between — over a thousand merged PRs a week. goose is Block's open-source, MCP-based, LLM-agnostic coding agent (Apache 2.0), which Stripe forked to build Minions.
What does "one-shot end-to-end" mean for Stripe's Minions?
It means a single autonomous run that starts with a human describing a task (usually a Slack message) and ends with a finished pull request that passes CI and is ready for review — with no human interaction in the middle. The human's involvement is bookended: brief at the start, review at the end. All Minion code is still human-reviewed before it merges.
Should a smaller team build its own coding agent?
Almost certainly not from scratch — the value the giants get comes from a huge integration surface (Stripe's 400+ tools, Ramp's full-environment sandboxes) that takes serious investment. The transferable move is to adopt a good off-the-shelf agent and invest in the part that's actually yours: feeding it your context via rules files and MCP servers, and improving developer experience (which doubles as agent-readiness).
What role does MCP play in all of this?
The Model Context Protocol is the connective tissue. goose is built on MCP, Stripe's "Toolshed" is an MCP server hosting 400+ tools, and MCP is how all these agents reach internal documentation, ticketing, code intelligence, and live systems. It's the standard that lets the swappable model talk to the proprietary context — which is exactly why it's become the center of gravity. (More on that in MCP, skills, and workflows explained.)
The bottom line
The headline looks like fragmentation — every big company reinventing the coding agent. It isn't. They're all renting the same intelligence from the same handful of model labs, and they're all building the same three things on top of it: a way to feed the agent their proprietary context, an integration surface that connects it to their real systems, and an ownership boundary they control. The model is the commodity. Everything that makes it theirs is the product.
Which is oddly clarifying for everyone else. You don't need to out-build Stripe to get the lesson. The leverage was never in the agent — it was in the context and tooling you wrap around it. Ramp and Stripe just proved how far that goes when you take it seriously: a tool that writes most of its own code, and a fleet that merges a thousand PRs a week. The agent was the easy part. The integration was the moat.
Sources: Ramp on why they built a background agent and how they built it on Modal, Stripe on Minions, and Block introducing goose. If this thread interests you, it pairs with my notes on when AI builds itself, the compute-budget era, and MCP, skills, and workflows.