Amplitude cuts development cycle from one month to two days with OpenAI AI agents

An agent that decides what to build, not just how to build it

In a case study published by OpenAI, Amplitude describes how its product agent Wave can compress the interval between identifying an opportunity and shipping the improvement to around 1 to 2 days, according to the company's own estimate, compared with what typically took about a month. Amplitude says Wave is about 80% built on OpenAI models: GPT-6.1 Sol, GPT-6 Luna, and GPT-Image-2.5 Flare.

The described flow works like this: the team gives Wave a product area and the metrics it wants to improve. The agent cross-references Amplitude's own usage data, session replays, customer feedback, and the source code to find and prioritize opportunities, design solutions, and coordinate implementation between people and coding agents, including Codex. Afterward, it tracks the outcome and uses that learning for the next round.

Amplitude's CEO sums up the shift in AI's role in the process:

AI can now find useful work we never thought to assign it. OpenAI's models can investigate a problem, write and run code, and use the results to decide what to try next.

Spenser Skates, CEO of Amplitude

A model router, not a single model doing everything

The most relevant point for anyone building agent systems isn't the final result, it's the architecture behind it. Amplitude doesn't use a single frontier model for everything: it distributes tasks by specialty, cost, and latency.

• GPT-6.1 Sol handles the opportunity manager and deep investigations in code and data, where reasoning needs to be strong and well-grounded.
• GPT-6 Luna runs frequent, cheap tasks, like scanning code and running small evaluation checks, repeated hundreds of times.
• GPT-Image-2.5 Flare generates mockups and wireframes using session replay screenshots as visual reference.

This division of labor is the pattern worth replicating in any agent system in production: reserve the more expensive reasoning model only for what truly requires depth, and push volume to smaller, faster models.

The test Amplitude ran on itself

Amplitude used Wave to investigate its own homepage, where generic suggestion cards were meant to help users start a conversation with an AI agent. In a sample of 100 session replays, 80 users typed their own question and only 12 clicked on a suggestion: the feature was being largely ignored.

Wave proposed personalizing the cards based on recent charts, dashboards, or the user's referring page, and delivered both a mockup of the change and a technical plan, including keeping free-text typing and showing generic suggestions when there wasn't enough context to personalize. After a brief review, the team handed the work to a coding agent and ran an A/B test.

The result: messages sent through the homepage cards rose 160% compared with the control, on the very first day. A senior Amplitude engineer sums up why this kind of adjustment usually goes unnoticed:

It is a great example of how non-groundbreaking things that just get ignored can increase the adoption of features in unexpected ways.

Eric Carlson, Senior Principal AI Engineer at Amplitude

Who still decides what goes to production

Wave doesn't eliminate human review, it reorganizes where it happens. According to Amplitude, most bug fixes go straight to coding agents without manual approval, while new features and bigger bets still require human review before deployment.

This is the piece that explains the speed: among experiments, flags, and guides shipped by customers based on opportunities Wave found, the distribution of time-to-ship was:

• 1 in 4 shipped the same day Wave identified the opportunity;
• half went into production in under 4 days;
• two-thirds shipped within a week.

There's a caveat OpenAI itself includes in the material: this curve was interpolated from milestones provided by Amplitude, it's illustrative, not a series of individual point-by-point observations. It's directional data, not a statistically precise metric.

The numbers behind each model's selection

Amplitude published internal evaluations that justify the model routing. For the Opportunity Investigator, the criteria were corroborating findings, avoiding false positives, incorporating evaluator feedback, recovering from tool failures, and keeping claims aligned with evidence:

For the Data Science Agent, Sol didn't win on raw score, but it won on cost and other criteria:

Sol scored better on tool-contract compliance, uncertainty estimation, and evidence grounding, even while losing on overall score by a small margin. For anyone deciding which model to use in a production agent, this table is a useful reminder: a higher standalone score isn't the same thing as better cost-effectiveness for the use case.

In wireframe generation, GPT-Image-2.5 Flare scored 80.3 out of 100 against 63.9 for another image model, in an evaluation that covered communication quality, product fidelity, instruction adherence, text and interface legibility, and visual coherence across 15 different opportunities.

What can't be copied directly from this case

All these numbers come from material published by OpenAI itself about a customer that uses OpenAI's models. The names of the competing models aren't disclosed, the full eval methodology isn't publicly detailed, and there's no independent benchmark to verify the results. It's well-instrumented marketing data, not a peer-reviewed paper.

It's also worth noting that Wave, according to the material itself, is still in beta with customers across different industries: it isn't a mature product tested extensively at scale. And the per-call cost of US$1.28 to US$2.63 per dispatch, multiplied across hundreds of investigations, is a real budget line that any team looking to build something similar needs to account for before promising two-day cycles to leadership.

What's left for builders

The pattern that survives skepticism toward case-study numbers is the architecture: giving an agent direct access to product telemetry, session replays, and source code, routing it between different models depending on the task, delivering a ready technical plan for a coding agent like Codex to implement, and keeping humans as the gatekeeper for what carries more risk. This is replicable with any agent stack, it doesn't depend on being an Amplitude customer.

The company's stated bet is that as reasoning and coding models improve, more investigation and implementation work goes to agents, freeing up the team for other priorities while the product keeps getting refined in the background. For engineering teams evaluating whether to build something similar, the practical question isn't whether the model is good enough, it's whether there's product data (replay, analytics, code) structured enough for an agent to investigate without hallucinating priority.