Greptile uses GPT-6 Astra to test running apps, not just code

Greptile, a startup building AI agents that review and test code changes with full context of the codebase, is now using GPT-6 Astra's computer use to test live applications at scale — moving bug detection beyond static code review and into simulating what real users actually experience.

"We are in the business of reducing bugs and making the world's software more reliable," says Co-founder and CEO Daksh Gupta.

That single sentence frames the company's whole strategy. And it explains why Gupta believes his mission requires more than reading code. It requires testing an application's behavior as well. GPT-6 Astra gives Greptile a way to automate that testing at scale, something that was previously out of reach for most engineering teams.

What does full pull request validation actually involve?

Validating a pull request, as Greptile defines it, involves four checks:

• Whether the code is logically correct
• Whether it does what the developer intended
• Whether it is secure
• Whether it avoids breaking existing functionality

The critical point, according to Gupta, is that some of this testing cannot happen by reading code alone. You need to actually run the application, because reading the source might not reveal the problem at all.

He offers a concrete example. Imagine a button that disappears when a website is viewed on an iPhone. Nothing in the code diff screams "broken." The bug only shows up on a specific screen size, in a rendered browser, during a user's journey through the app.

With GPT-6 Astra, Greptile's agents handle this end to end. The system can start a development server for a pull request, resize the browser to an iPhone-sized viewport, and simulate a user moving through the application. The model's visual understanding lets it inspect the screen and spot the hidden button.

That is the capability that changes the economics of quality assurance. Traditional QA cannot keep pace with modern AI-assisted development cycles.

Why does automated testing matter now?

Gupta is blunt about the mismatch between old testing practices and new shipping speeds.

"A QA firm testing all of your changes is just impractically slow considering how fast we're able to ship code with these models," he says.

The stakes here are market-wide. AI coding tools have compressed the time between writing code and deploying it. Every stage of the software pipeline that still depends on slow human labor — review, testing, security checks — becomes the new bottleneck. Greptile's bet is that automated validation is not a nice-to-have but the necessary complement to automated code generation. If machines write the code, machines have to check it.

Gupta also flags a second, darker consequence of more powerful models: they cut both ways. More capable AI makes it easier for attackers to exploit applications, putting companies at risk — including companies that previously would not have been typical targets. A startup that was once too small to interest sophisticated attackers now faces adversaries armed with the same class of models writing its defense.

How does Daybreak change Greptile's security posture?

Greptile runs its security hardening on Daybreak, and Gupta frames the choice in explicitly adversarial terms.

"We want to make it very easy for even a startup to secure their systems," says Daksh. "With Daybreak, we're able to do this in a way that is very safe, and we can ensure that our customers have more sophisticated defense mechanisms than the adversaries have offense mechanisms."

That quote carries the core logic of the company's security pitch. The goal is an asymmetric outcome: defenders with better tooling than attackers. And the target customer is deliberately broad — not just enterprises with dedicated security teams, but startups that historically had to accept vulnerability as the price of moving fast.

What role does Codex play?

Codex enters the picture through Greptile's Knowledge Base, a system that indexes a company's codebase and documents how it works in a form that both people and agents can read. Greptile exposes that documentation to Codex through a Model Context Protocol (MCP) server.

The effect is practical: Codex can write code that follows the customer's existing patterns rather than inventing its own conventions. Thousands of customers have connected Codex to Greptile's knowledge base, according to Gupta.

That adoption number matters. It shows the knowledge base is not a side project — it is infrastructure that a large share of Greptile's customer base already routes its AI coding through.

Does context actually reduce rework?

Greptile measures the impact concretely. The team tracks how often AI-generated code is reverted — a clean, behavioral signal of whether generated code actually stuck.

"When we provide agents with context, fewer reverts happen and customers save time and save inference," Daksh says.

The savings are two-fold. Customers spend less time reworking the same changes, and they burn less inference — the compute cost of regenerating code that was wrong the first time. Those recovered resources can go toward new work instead of repairing old output.

For any team budgeting for AI development, that is the difference between a tool that pays for itself and one that quietly multiplies its own cost through rework.

How does Greptile use these tools internally?

Greptile is also its own best case study. The company uses Codex to build its own software and agents.

"We are massive users of Codex," Daksh says. "We have enormous amounts of usage across every single function, engineering in particular."

Note the phrase "every single function." Codex is not confined to the engineering team at Greptile; usage spans the whole company, with engineering as the heaviest consumer.

For Gupta, the constraint on Greptile's growth is no longer model capability. He says model intelligence is already sufficient for many tasks. The only real bottleneck, as he explains it, is how quickly the team can turn ideas into working software. That is why he sees Ultrafast — OpenAI's speed-focused offering — as a way to accelerate development rather than as a source of new ability. When intelligence is abundant, velocity becomes the scarce resource.

What is the endgame?

Gupta's longer-term goal is stated plainly: make changing and shipping critical enterprise software as easy as shipping a side project. That is an ambitious target. Enterprise software carries compliance burdens, integration risks, and blast-radius concerns that side projects never face.

He counts on OpenAI to help Greptile build the validation layer that such ease would require. The theory of the case is consistent across everything the company does: reliable, fast, context-aware validation is what converts AI-generated code from a gamble into shippable software.

If Greptile gets there, the payoff is a world where the gap between a one-person side project and a critical enterprise system is measured in safeguards, not in weeks of manual QA. The company is betting that models like GPT-6 Astra, Daybreak, and Codex are already good enough to start closing that gap now.