I wanted to find problems where AI could be indispensable, not just impressive.

I wanted to find problems where AI could be indispensable, not just impressive.

I've spent over a decade watching AI evolve. From my PhD at Stanford to building chatbots at a startup, from helping Square automate customer support to working on Gemini at Google. Each step gave me a taste of how AI can bring step function change to society.

But when I look at where AI is today, it feels indisputably magical yet at the same time most applications of it feel a bit like solutions in search of problems. Think about generational technologies that came before AI: If the internet disappeared tomorrow, the world would stall. If Google went down, we would panic and think the internet stopped working. On the contrary, if most AI applications vanished? We'd be mildly inconvenienced.

I wanted to find problems where AI could be indispensable, not just impressive.

That’s precisely why I joined Resolve AI. To make something that I’d find indispensable even for myself: bring a step function change in how we work with software engineering using Agentic AI.

Why focus on software engineering problems?

As an engineer working on real systems (especially bigger companies, but really throughout my career), the majority of my time goes into understanding production systems and not writing code. Picture this for understanding the magnitude. If I print out all the code I write in a week and retype it into a text editor as-is, it would only take me a few hours. The real engineering work isn't coding — it's understanding.

Understanding is tied to what's actually happening in production. Understanding how a request flows through seventeen different services. Understanding why this endpoint is suddenly taking 2.3 seconds instead of 0.3 seconds. Understanding the difference between what the system was designed to do and what it's actually doing. For fixing anything but the smallest bugs, the place I start isn’t staring at the code, it’s dashboards and traces and logs.

This is also where human intelligence starts to reach its limits. Not because we're not smart enough, but because our distributed systems have evolved beyond the scope of human working memory. We've built systems that are fundamentally more complex than any single brain can hold.

Even with the current state of AI, debugging production systems with AI is a hard technical problem to solve. At the same time, it is a problem that engineers face daily. It's universal suffering that scales exponentially. The bigger you get, the more complex your systems become, the more this problem compounds.

Why Agentic AI for software engineering?

AI today reminds me of a brilliant teenager: obviously capable, but we're not exactly sure for what. We've built technology that can write poetry, generate art, and hold philosophical conversations. Personally, I want my AI systems to eliminate the parts of my job that I don’t like. I’m happy to write my own [bad] poetry, I love building software, and while I’m welcoming of AI enabling me to write software quicker, I’m fundamentally fine with writing code too.

On the flip side, what makes me miserable is debugging production systems. Engineers like me are manually sifting through logs to understand our systems. When something goes wrong, engineers are still playing twenty questions. If you’re unlucky, playing twenty questions under the time pressure and unpleasant attention that comes from your service being down.

Using Agentic AI for helping us navigate production systems isn't glamorous. But here's what makes it irrationally cool:

• It's solving a large pain, even if it's narrower: Every engineering team on the planet deals with complex systems and uncalled for incidents. It's a universal suffering that scales with size. The bigger you get, the more the problems grow.
• It's work that literally no one wants to do: I've never met an engineer who said, "You know what I love? Debugging production incidents". It's absolutely essential, completely unpleasant, and desperately in need of a solution.
• If we solved this and then disappeared, engineers would worry. Imagine systems that can explain themselves when they break. Imagine cutting incident resolution time by 70%. If Resolve AI vanished after delivering that, I'd be personally pissed. That's the kind of product I want to build.

Why Resolve AI?

I met Spiros and Mayank, and something clicked.

These weren't AI researchers who stumbled upon an interesting problem. They were engineers who spent years in the trenches, who got the 3 AM calls, who built OpenTelemetry: the foundational layer that lets us see what's happening in our production systems. They didn't just identify the problem; they lived it and built the infrastructure that makes solving it possible.

There's something uniquely powerful about founders solving their own problem. They're not trying to build "AI for everything". They're obsessed with doing one thing exceptionally well. They've already proven this works. Real customers, meaningful traction, clear product-market fit in a segment that desperately needs what they're building.

Why now?

The technology has finally caught up to the problem. All the research breakthroughs in agent orchestration, tool use, and reasoning are converging into practical applications. Understanding context, even uncaptured, across vast amounts of unstructured data is possible. That's exactly what our production systems require.

But more importantly, the pain has reached a tipping point. Systems are getting more complex faster than teams are growing. The old methods of tribal knowledge and manual investigation simply don't scale. Plus, as AI is making it faster and faster to write code, the bottleneck of maintenance, understanding, and debugging becomes ever more acute.

The road ahead

I envision a world where debugging is as easy as vibe coding. Where when something breaks, the system itself can tell you what happened, why it happened, and how to fix it. Where production incidents become learning instead of panic attacks.

We're solving a problem that pushes the limits of what agentic AI can do: reasoning across complex, unstructured data, coordinating multiple tools, making sense of systems no single human can fully comprehend.

The impact is profound: we're eliminating the work that drains engineers while accelerating and democratizing the scaling of software. Every new service and integration makes production systems exponentially harder to understand. We're taking this complexity and turning it into something simple.