Sazabi Is Rebuilding Observability for a World Where AI Writes the Code

Something has quietly broken about the way we watch software run.

For the last fifteen years, the standard playbook for keeping a production system healthy has looked roughly the same. You instrument your code by hand. You emit metrics, and you build dashboards on top of them. You define static thresholds—CPU over 80 percent, error rate over 1 percent—and you wire those thresholds to alerts. When something goes wrong, a human gets paged, opens a dozen dashboards, and starts the slow archaeological work of correlating graphs until the root cause reveals itself.

That playbook was designed for a world where software changed slowly and predictably. A team of engineers shipped a handful of deploys a week, each one reviewed line by line, and the system's behavior stayed mostly within known bounds. The dashboards you built on Monday were still meaningful on Friday.

That world is disappearing. AI coding agents now write and ship code at a pace no human review process was built to absorb. Systems change continuously. The dashboards you built on Monday describe an application that no longer exists by Wednesday. The instrumentation you added last quarter doesn't cover the endpoint an agent added this morning. And when something breaks, it increasingly breaks in code that no human on the team ever actually wrote.

This is the problem Sazabi is built to solve.

Sazabi is an AI-native observability platform for fast-moving engineering teams. Instead of static dashboards and brittle instrumentation, it's built around chat, autonomous agents, and a logs-first architecture that helps teams detect, investigate, understand, and fix production issues faster. The company describes what it's building bluntly: Datadog for the AI era.

Observability Was Built for a Deterministic World

To understand why a new platform is warranted, you have to understand what the old one assumed.

Traditional observability rests on three pillars: metrics, logs, and traces. Each is a separate data type, with its own storage system, its own instrumentation, and its own cost model. Getting real coverage means threading all three through your application by hand—adding metric counters here, structured spans there, log lines everywhere—and then paying to store each of them in its own backend. The result is expensive, labor-intensive, and perpetually out of date, because every new feature requires a new round of manual instrumentation before it's visible at all.

Worse, the entire model is reactive by design. Dashboards don't watch themselves. Alerts fire only on the conditions you thought to define in advance. A static threshold catches the failure mode you anticipated and stays silent on the one you didn't. So the actual work of understanding an incident falls to a human, at 3 a.m., manually pivoting between graphs and log searches trying to reconstruct what happened.

As J2 Ventures general partner Christine Keung put it in explaining why the firm led Sazabi's seed round: "Software systems are becoming increasingly probabilistic and dynamic. Existing observability tools were built for a far more deterministic world. If Datadog defined observability during the cloud-native era, Sazabi is defining it for the AI-native one."

That's the crux of it. The cloud-native era gave us more infrastructure to watch. The AI-native era gives us infrastructure that changes underneath us faster than we can watch it—and a growing share of that change is authored by machines. The tooling has to change with it.

Logs Are All You Need

Sazabi's most contrarian design decision is also its most clarifying: it treats logs as the single source of truth.

The conventional wisdom says you need all three pillars because they answer different questions—metrics for aggregate trends, traces for request flow, logs for detail. Sazabi's insight is that this separation is an artifact of a pre-AI world. As the company frames it, logs are events, metrics are aggregated events, and traces are collections of start-and-end events. Everything the other two pillars express is, underneath, a view over events. What made the three-pillar split necessary was that machines couldn't cheaply read and reason over raw logs at scale. With modern AI, they can.

So Sazabi collapses the stack. It ingests logs and lets its agents do the work that metrics and traces used to require dedicated instrumentation to support: answering complex queries, performing aggregations, profiling endpoints, and tracing a request through an entire system—all from log data alone. The instrumentation experience gets dramatically simpler, and you get the analytical power of a full observability platform without maintaining three parallel pipelines to feed it.

The practical payoff is twofold. Instrumentation stops being a tax on every new feature, because you're emitting one kind of signal instead of three. And storage costs fall, because you're not paying to warehouse the same underlying events three times in three formats. For a fast-moving team shipping constantly, removing the instrumentation bottleneck is the difference between observability that keeps up and observability that's permanently behind.

Agents Instead of Dashboards

If logs-first is the architecture, autonomous agents are the interface.

Sazabi replaces static monitors with what the company calls agentic anomaly detection—less a dashboard you stare at and more a team of staff engineers constantly watching your application for issues. Rather than firing on thresholds a human defined in advance, the agents learn what normal looks like for your system and surface the deviations that matter, including the failure modes nobody thought to write an alert for.

When something does look wrong, the agents don't just page a human and stop. They investigate. In a single recent month, Sazabi reports running 8,000 background investigations and detecting 2,000 issues across the teams it serves—the kind of first-pass diagnostic work that would otherwise consume an on-call engineer's night. Each investigation aims to move past "here's a spike on a graph" to "here's what changed, here's the likely cause, and here's the fix."

That last step is where Sazabi gets genuinely ambitious. When the platform identifies a problem, it can open a pull request with the change to address it. If Sazabi doesn't yet have a native integration with some service in your stack, it can open a pull request adding the necessary instrumentation itself, rather than leaving that as homework for your team. In the same month cited above, it opened 200 pull requests. The company describes the destination this points toward as self-healing software: systems that detect their own faults, diagnose them, and propose the fix without a human having to drive every step.

The symmetry here is the whole thesis in miniature. AI agents are increasingly the ones writing the code that ends up in production. Sazabi's agents are the ones watching that code, catching what it broke, and writing the code to fix it. The observability layer is being rebuilt to operate at the same speed, and in the same medium, as the development layer that now feeds it.

Why This Company, Why Now

Timing and founder fit are doing a lot of work in Sazabi's favor.

The "why now" is the surge of AI-generated code and the incident load that comes with it. Coding agents have made it trivial to ship features fast, but speed of generation has outrun speed of validation. Studies circulating through 2026 have put AI-generated code at roughly 1.7 times the bug rate of human-written code, with a correspondingly higher share of critical and major issues. AI agents don't tend to make small, familiar mistakes; they make confident, large-scale ones—rewriting a caching layer, quietly changing a query pattern, removing a guardrail because it looked like it hurt performance. More code, shipped faster, by authors who don't carry the system's full context, means more production incidents, changing more continuously. That is precisely the environment traditional dashboards and manual incident response were never built to survive.

The "why this founder" is Sherwood Callaway, a two-time Y Combinator founder who has lived this problem from the inside. He helped build the infrastructure and observability functions at Brex, where he saw firsthand how quickly modern development outpaces the tooling meant to keep it reliable. He previously founded Opkit (YC W23), which he built and sold, and went on to lead AI infrastructure work afterward. He's building Sazabi with a small, senior team—nine engineers including several early members of Brex's team and multiple people who have founded observability companies before. This is not a group learning the domain on the job.

Investors have noticed. Sazabi raised an $8 million seed round led by J2 Ventures, Village Global, and Y Combinator, with participation from Orange Collective and more than sixty angel investors drawn from the companies building the AI stack itself—Vercel, Cursor, LangChain, OpenAI, Anthropic, GitHub, Replit, and Browserbase among them. When the people building the coding agents put their own money into the platform that watches what those agents ship, it's a strong signal that the incident problem is real and felt at the source. In its early going, Sazabi reports onboarding 35 new teams and ingesting 2 terabytes of logs in a single month—the kind of early traction that suggests the pain is acute and the wedge is landing.

The Category Being Redrawn

Step back, and Sazabi is a bet on a structural shift in what "keeping software running" even means.

For a generation, observability was a human discipline supported by tools. The tools collected the data; the humans did the interpreting. You bought dashboards and query languages and paging systems, and then you staffed a team of engineers to sit in front of them, because interpretation—correlating signals, forming hypotheses, tracing a symptom back to a cause—was work only people could do. Every improvement in observability tooling was, at bottom, an improvement in how efficiently a human could investigate.

The AI-native version inverts that relationship. The interpretation itself becomes something software can do continuously, in the background, across every service at once—work no human team could match in volume or speed. The human moves up a level, from investigator to reviewer: approving the pull request the system already wrote, setting the goals rather than pivoting between the graphs. It's the same shift AI is driving across so many technical disciplines—the machine takes over the analytical first pass, and the person is freed to supervise the outcome rather than grind through the process.

That's why "Datadog for the AI era" is a more precise claim than it first sounds. Datadog didn't just build better monitoring; it defined what observability meant for the cloud-native generation, and an entire category organized itself around that definition. Sazabi is arguing that the AI-native generation needs a different definition—logs instead of three pillars, agents instead of dashboards, fixes instead of alerts—and it's moving to author that definition early.

If the last era of observability was about giving humans better tools to watch their software, the next one is about giving software the ability to watch, understand, and repair itself. Sazabi is building for that world—and betting that in a world where AI writes the code, AI is also what keeps it running.