5 Playbooks from Companies Running Agentic Engineering Right Now

If you run an engineering org right now, you’re probably in one of two places. Either your team is using AI coding assistants and getting incremental gains: faster autocomplete, better test drafts, quicker documentation. Or you’ve heard about companies where AI agents autonomously ship production code, and you’re trying to figure out how to get there without blowing up your codebase or your team's trust. 

This report is for the second group. The gap between "AI that suggests code" and "AI that owns a feature from ticket to merged PR" is not a model upgrade. It’s an infrastructure problem, a cultural shift, and an operating model redesign all rolled into one. The five companies here crossed that gap, and they did it in ways that are surprisingly specific and surprisingly replicable. 

We researched five companies that shared publicly how they run AI-led engineering. Not AI-assisted. AI-led. Agents that plan, write, test, and submit code with minimal human intervention. We picked these five deliberately. They’re different sizes, in different industries, and in different geographies. Stripe is a private payments giant. Shopify is public e-commerce. Nubank is a Latin American digital bank. Coinbase is a mid-size crypto exchange. Block (Square, Cash App) is a public fintech company. It also happens to be the company that built the open source agent framework Stripe later forked to build their own. 

Each profile covers what they built (the engineering details, not the press release), what you can apply in your own org, and a reference pattern you can sketch on a whiteboard with your team. The final section maps the infrastructure patterns that show up across all five. In other words, how you can go from "we have an agent" to "our agents run reliably in production."

Stripe 

Private | ~8,000 employees | Payments infrastructure

Stripe built internal agents called Minions (forked from Block's open-source Goose framework). They made Minions incredibly easy to use. An engineer sends a Slack message, tags the Minions bot with a task description like a bug fix or a dependency update and walks away. The agent spins up an isolated cloud machine, reads relevant docs, writes the code, runs linters and CI, and opens a pull request. Every PR is human-reviewed but none contain human-written code. Stripe sees over 1,300 of these PRs merge every week. At this stage, Minions handle scoped, well-defined tasks (not architectural decisions or ambiguous feature work). 

The critical insight was that Minions work because of infrastructure Stripe built years before AI agents existed: devboxes. Devboxes are cloud machines pre-loaded with the entire codebase. They spin up in 10 seconds because Stripe proactively provisions and warms a pool of them. Engineers already used one devbox per task. Agents fit perfectly into the same pattern. Since devboxes run in a QA environment, agents get full permissions with zero production data access. The best agent infrastructure turned out to be developer infrastructure. 

Stripe also designed hybrid blueprints, a structured alternation between open-ended LLM steps and mandatory deterministic gates. The agent writes code, the system automatically lints, the agent fixes errors, the system commits. The agent never decides whether to lint. The system enforces it. 

What can you apply? 

1. Audit your dev environment spin-up time. If it takes over 60 seconds to get a clean, isolated environment with your full codebase, fix that first. Fast environments are agent infrastructure. 

2. Define hybrid blueprints for your top 3 repetitive task types. Map the creative steps (agent writes code) vs. deterministic gates (system runs linter, tests, commit). This turns unpredictable agent behavior into a structured, auditable workflow you can reason about. 

3. Trigger agents from where engineers already work like Slack, Linear, Jira. If kicking off an agent takes more effort than doing the task yourself, nobody will delegate to it

Shopify 

Public | ~12,000 employees | E-commerce platform

"If you don't figure out how to harness agents in 2026, you'll be behind."

- Farhan Thawar, VP Engineering, Shopify

Shopify did something that sounds simple but almost nobody actually does: they standardized the infrastructure, not the tools. They built a centralized LLM proxy which is an API gateway that routes all AI requests through a single endpoint. Every tool (Cursor, Claude Code, Copilot) connects through it. Underneath, the company gets model routing, token-level cost tracking per team, usage analytics, and the ability to swap models without any engineer changing their workflow. 

Senior engineers now launch multiple agents simultaneously on different parts of a codebase. The engineer reviews outputs, discards what fails, merges what works. CTO Mikhail Parakhin described 45+ minute agent sessions with multi-model critique loops. The agent iterates on its own work before a human sees it. Internally, they also built Tangle for reproducible ML workflows, Tangent for auto-research loops (used by PMs, not just engineers), and SimGym for customer behavior simulation before deployment. 

CEO Tobi Lutke's internal memo made using AI operating policy. He announced that teams must prove why jobs cannot be done using AI before requesting new headcount. AI usage is also a key part of their performance reviews. 

What can you apply?

1. ‍‍Build an LLM proxy. Concretely: an API gateway that all AI tool traffic routes through. Log every request with team, model, token count, and cost. This gives you the data to make model and budgeting decisions and lets you swap models centrally. 
2. Run a parallel-agent session with a senior engineer. Have them launch 3-5 agents on the same task using different approaches or models. Review and merge the best. Time the new way vs. the old way.
3. Add one question to your headcount request form: has this team maximized automation before asking for a new hire? One policy change forces serious evaluation across every team.

Nubank 

Public | ~8,000 employees | Latin American digital bank

Nubank had an 8-year-old ETL monolith (millions of lines of code) that needed to be broken into sub-modules. The original plan was to have 1,000+ engineers work on it for 18 months, doing roughly 100,000 data class implementations moved one by one. In other words, the kind of project that makes your best engineers quietly update their resumes. 

They deployed Devin (Cognition's autonomous coding agent) and did something worth studying. They didn’t point it at the monolith and say "migrate this." They decomposed the problem into a single repeatable sub-task, collected examples of how engineers had done it manually, and fine-tuned Devin on those examples. They also built a separate evaluation set of reserved manual migrations that the agent had never seen to measure quality before scaling. Fine-tuning doubled task completion and cut per-task time from 40 minutes to 10. Then they ran multiple Devin instances in parallel. Data, Collections, and Risk teams finished their migrations in weeks. 

The value is not "AI wrote code faster." It’s that 1,000 engineers were freed from 18 months of soul-crushing migration work and could build products for customers instead. That is the ROI calculation that matters: not tokens saved, but engineering capacity redirected to value-creating work. 

What you can apply

1. Identify your "Nubank migration." Every org has one: a framework upgrade, a dependency migration, a test backfill, a logging standardization. Anything that’s large, repetitive, ad well-understood. These are the highest-ROI agent workloads because the pattern is known and the volume is high. 
2. Collect 10-20 manual examples before you deploy an agent. Feed them as few-shot examples or fine-tuning data. Nubank saw 2x better completion and 4x speed from this step alone. A generic agent guesses your conventions; a trained one follows them. 
3. Build the eval set before you scale. Reserve manual examples the agent has never seen, run the agent against them, and measure: did the output match what a human would have produced? Without this gate, you are deploying at scale on faith.

Coinbase 

Public | ~3,700 employees | Crypto exchange 

Coinbase's shift started with a Slack message from the CEO. Brian Armstrong told every engineer to onboard AI coding tools by the end of the week. Engineers who had not done so by Saturday were called into a meeting to explain why. The signal was clear: this is not optional. 

The engineering team then built what they call paved roads: standardized templates for deploying agent automations into production. Each template includes built-in observability (traces, logs, error rates), a human approval workflow for actions with side effects, structured error handling with fallback paths, and connection to Coinbase's internal business systems via managed integrations. In six weeks they proved the pattern on multiple automations, put two into production saving 25+ hours per week on tasks like compliance document processing and internal data reconciliation, and published internal guides that cut new agent build time from 12+ weeks to under a week. 

They also deployed autonomous testing agents that run scenarios and self-evaluate findings without human guidance, and multi-agent decision support systems that augment internal decision documents with explainable, auditable analysis. The platform engineering team at Coinbase treated agent deployment the same way good platform teams treat service deployment, with a golden path that handles observability, error handling, and approval so individual teams do not reinvent the wheel. 

This is what Coinbase shared as an example of their agent infrastructure:

What you can apply

1. Build one paved road: a reusable template for agent automations that includes observability (OpenTelemetry traces, structured logs), an approval gate for production-impacting actions, and managed connections to your internal systems. Coinbase cut agent build time by 90% with this one investment. 
2. Start with testing agents, not coding agents. Autonomous QA agents that generate test scenarios, run them, and report findings are lower-risk and often deliver faster ROI by catching regressions that manual QA misses. 
3. Pick an internal process automation first. Compliance checks, data reconciliation, report generation are less risky than code-writing agents and let you prove the paved road pattern before applying it to the SDLC.

Block 

Public | ~12,000 employees | Fintech (Square, Cash App)

Block is the company that built Goose, the open-source agent framework that Stripe later forked to create Minions. That lineage matters: the architectural decisions Block made in Goose (autonomous execution loops, MCP-based tool integration, model-agnostic design) became the foundation for one of the most successful autonomous coding deployments in the industry. 

CTO Dhanji Prasanna described the core philosophy on the Sequoia podcast: let the agent loop run as far as it can. If it stumbles, it backs up and tries another approach. Block intentionally avoided over-engineering agent workflows. They instead let agents learn from real use and adapt organically. As a result, engineers reported saving 8-10 hours per week, and Block tracks "manual hours saved by AI" as a company-wide metric with a target of 25%.

The most surprising outcome for Block was that non-engineers started using Goose. Sales and finance teams now write their own dashboards and internal tools without filing engineering tickets. Prasanna said they never expected this but it turns out that an autonomous agent with a good execution loop and access to your systems lowers the barrier enough that domain experts build their own solutions.

Goose interactive loop:

What you can apply

1. Measure manual hours saved, not tokens consumed. Block tracks this weekly at the company level. It is the most honest metric for agent ROI because it ties directly to engineering capacity. Ask your teams: how many hours per week does each engineer save by delegating to agents? 
2. Avoid over-engineering agent workflows. Block let agents learn by doing autonomous loops that back up and retry on failure, rather than brittle predefined paths. Start with a simple loop (plan, execute, evaluate, retry) and add structure only where failures are systematic. 
3. Open agents to non-engineering teams. If your agent framework has access to internal systems, domain experts in sales, finance, or ops can build their own automations. This multiplies impact beyond the engineering org.

What can we learn from these companies?

Building an agent is easy. All it takes is a few LLM calls, a prompt, some tool definitions, and it is doing work in minutes. But running it reliably in production, across teams, with real data and real consequences? That requires infrastructure nobody budgets for when building the demo. Every company in this report discovered this and built infrastructure to get to production

Centralized integrations, not scattered connections

Stripe routes all agent work through isolated devboxes with managed credentials. Shopify routes all AI requests through a centralized proxy. Without this, every team wires its own connections and you end up with different permissions, different scopes, different failure modes. Agents need a managed integration layer, not integrations where individual developer tokens expire on a Friday night. 

A context layer that agents can actually use

Nubank fed agents fine-tuned examples of how engineers do the work. Block lets agents learn from real execution loops. Shopify's SimGym provides live customer behavior context. Static markdown files go stale within days. The companies that succeed give agents live, org-specific context: service ownership, recent deploys, team conventions, past decisions and their outcomes. 

Visibility into what agents exist and what they do

As agents multiply faster than headcount, you get sprawl: duplicate agents across teams, nobody knows what is running, expired credentials go unnoticed. Coinbase solved this with paved roads and a registry of what automations exist. An agent registry is as essential as a service catalog. Without one, your CISO cannot answer "what agents do we have and what can they access?" 

Measurement that goes beyond 'did it run'

Nubank built eval sets before scaling. Block measures manual hours saved weekly. Stripe reviews every PR. You need three layers: observability (what did the agent do), evals (is it getting better or worse when you change models or prompts), and outcome metrics (is it delivering business value). Most orgs only have the first. 

Human-in-the-loop as architecture, not afterthought

Stripe puts humans at the review stage, not the writing stage. Coinbase built approval gates into the paved road template. Block's Goose runs autonomous loops but surfaces results for human judgment. The companies that succeeded designed the human touchpoint as a permanent architectural decision. 

Governance that scales with agent count

Today your org might have 10 agents. In a year, you’ll have thousands of them created by engineers, running across tools, with varying permissions. Shopify tied usage to performance reviews. Coinbase standardized agent creation templates. Block contributed Goose to a Linux Foundation governance framework. Agent governance needs to be as systematic as service governance.

The tooling is available. 

The question is infrastructure. 

Sources 

Stripe 

InfoQ: "Stripe Engineers Deploy Minions, Autonomous Agents Producing Thousands of Pull Requests Weekly" (Mar 2026) - infoq.com/news/2026/03/stripe-autonomous-coding-agents 

ByteByteGo: "How Stripe's Minions Ship 1,300 PRs a Week" (Mar 2026) - blog.bytebytego.com/p/how-stripes-minions-ship-1300-prs Stripe Dev Blog: "Minions: Stripe's one-shot, end-to-end coding agents" (Feb 2026) - 

stripe.dev/blog/minions-stripes-one-shot-end-to-end-coding-agents 

Shopify 

Bessemer Venture Partners: "Inside Shopify's AI-first engineering playbook" (Apr 2026) - bvp.com/atlas/inside-shopifys-ai-first-engineering-playbook Latent Space: "Shopify's AI Phase Transition" with Mikhail Parakhin (Apr 2026) - latent.space/p/shopify 

The Pragmatic Engineer: "How AI is changing software engineering at Shopify" with Farhan Thawar (Jul 2025) 

Nubank 

Building Nubank: "Enhancing engineering workflows with AI: a real-world experience" (Mar 2025) - building.nubank.com Devin / Cognition: "Nubank Customer Case Study" (Feb 2026) - devin.ai/customers/nubank 

Coinbase 

Coinbase Engineering: "Building enterprise AI agents at Coinbase" (2026) - coinbase.com/blog/building-enterprise-AI-agents-at-Coinbase Fortune: "Coinbase CEO urged engineers to use AI — then shocked them" (Aug 2025) - fortune.com 

Block 

Sequoia Capital: "Block's Prasanna: The Open Source Goose Transformation" (Feb 2026) - sequoiacap.com/podcast/training-data-dhanji-prasanna Block: "Block Open Source Introduces codename goose" (Jan 2025) - block.xyz/inside/block-open-source-introduces-codename-goose Linux Foundation: "Formation of the Agentic AI Foundation" (Dec 2025) - linuxfoundation.org 

Infrastructure concepts 

"The hidden technical debt of agentic engineering" (Apr 2026) - newsletter.port.io 

Google / NeurIPS: "Hidden Technical Debt in Machine Learning Systems" (2015) - proceedings.neurips.cc