Product Updates
November 15, 2026 • 12 min read

groundcover Investigations are a coworking space, not another AI SRE

An agentic investigation should feel like a process control system, and working with the agent should feel collaborative. Your coding agents, groundcover’s agents, and the engineers on call all work in the same place, against the same records, and everyone can see everyone else’s work. The groundcover investigator doesn’t push you out of the loop while it quietly makes its fix. It’s designed to pull you in. Investigations show you what every agent and sub-agent is checking, and that visibility invites people to get involved and ask questions.

Anais Dotis
Anais Dotis
November 15, 2026
12 min read
Product Updates

Most AI SRE products make a similar pitch, to hand your alert to the AI SRE and the agent returns a fix. It's an appealing idea, however it creates a processing bottleneck and information silo, not to mention that for the cost there often is not a lot of added value compared to any engineer’s personal agent with an MCP.

We built groundcover Investigations around a different idea. An agentic investigation should feel like a process control system, and working with the agent should feel collaborative. Your coding agents, groundcover’s agents, and the engineers on call all work in the same place, against the same records, and everyone can see everyone else’s work. Our investigator doesn’t push you out of the loop while it quietly makes its fix. It’s designed to pull you in. Investigations show you what every agent and sub-agent is checking, and that visibility invites people to get involved and ask questions.

So why can we build it this way when most AI tools can’t? It comes down to how groundcover runs. With our BYOC architecture, the investigation runs inside your own cloud, and we don’t charge you for the tokens your agents spend. Instead, the model calls go through your own LLM provider, at your provider’s price. That changes what we’re incentivized to build. A vendor that bills per token has every reason to keep the agent working alone and to hand you a tidy summary at the end. We don’t. We can let agents chase more hypotheses, show you every branch they’re exploring, and invite you to push back mid-investigation, because none of that turns into a bigger bill for you or a bigger margin for us.

In this post we'll walk through what that looks like in practice. First, we’ll discuss why we chose this approach of collaboration over agent autonomy. Next we’ll dive into how the groundcover investigator approaches a problem, with a real example from our own systems. Then we’ll show how the moderator works as an LLM-as-a-judge to keep the investigator service honest. And finally, how automation fits in without taking humans out of it.

The one-agent-at-the-center problem

Let's start with some examples of what's already out there. Resolve AI positions itself as an autonomous AI SRE, and at launch it said its goal was to auto-resolve 80% of alerts and incidents without human intervention. Dash0's Agent0 now runs automations that investigate and report on their own, and you can call it from Claude Code or Cursor over MCP. You hand it a question, and it hands you back a conclusion.

These are capable products, but they also create bottlenecks. One agent sits in the middle while your coding agents and teammates are left either serving it or waiting on it. This agentic loop is also psychologically draining on employees. As a recent Harvard Business Review piece points out, when AI chips away at people’s sense of skill, control and connection to their colleagues, they tend to disengage from it. Being sidelined while an agent works the incident does all three.

It’s also not how teams work anymore. Most engineers already have an agent they trust, and a lot of them have two or three. Adding one more agent to the pile doesn’t help if it can’t work alongside the others. What helps is consolidation: one place where all of that effort lands, so it adds up to a single investigation instead of five parallel ones.

A coworking space for agents and humans

That’s the job groundcover Investigations does. It’s the shared room, and the investigation tree is the whiteboard on the wall.

Different participants bring different strengths into that room. groundcover’s agents know your telemetry. They know your traces, logs and metrics and how to query them fast. Your coding agent knows your code. Neither one has the full picture on its own. So during an incident, the useful question for each part of a hypothesis is who has the better context to test it.

You don’t have to use our investigator to work in the room. We recommend it, and we think it’s good, but it’s one option. Your own agents can run the investigation instead, or work alongside ours. Whichever agents do the work, the moderator runs on every investigation. It holds everyone to the same standard for how an investigation should run. For example, nobody can close a hypothesis without findings that support it.

Collaboration between groundcover’s agents, your coding agents and Slack runs in both directions. Each one can send work and information to the others and get it back. When an investigation leads into code, the groundcover investigator can bring in your coding agent to check that code, for example through a Cursor Cloud Agent connector. In the other direction, your coding agent is already a participant in the investigation, whether or not our investigator is involved. When it needs telemetry, it can call a groundcover agent to fetch the relevant data. Then it publishes its own finding or assessment back into the investigation tree. Slack works the same way. groundcover Investigations posts updates to the incident’s Slack thread, and replies in that thread become part of the investigation. Every contribution is attributed to whoever made it, and every contribution lands in the same tree.

The humans are in the room too. An on-call engineer can open the investigation at any point, add context an agent doesn’t have, challenge a hypothesis, or stop an assessment branch that’s going nowhere. But a shared space only matters if the work inside it is good. So let’s look at the two agents that keep it that way, starting with the investigator.

How the investigator works

The groundcover investigator borrows from fault tree analysis, a long-standing method for investigating failures. It works top-down. It starts with the question, proposes hypotheses that could explain it, and then goes looking for evidence that supports or refutes each one.

Generating hypotheses is where an LLM really helps. The model has learned from a huge amount of public engineering writing, including postmortems, runbooks, docs and countless “why is my pod crash-looping” threads. With the right instructions, it can reason about a failure the way an experienced SRE or infrastructure engineer would, and most of the time its first round of hypotheses is a pretty good one. It also doesn’t start from scratch on every incident. The investigator can look at past investigations in your environment, see which hypotheses held up and which went nowhere, and use that to decide where to look first.

On a root question, we push it to open several hypotheses instead of settling on the first plausible story. That keeps it honest, and it shows you the problem was actually explored.

Here's why that structure matters, from one of our own early runs.

We pointed the investigator at a real issue in our internal environment: our metrics-aggregator service was having trouble writing data. In our first prototype runs, the agent kept landing on the same conclusion–The aggregator's downstream, vminsert, was rejecting writes. So the investigation closed.

This conclusion was true. It was also a symptom. Knowing that vminsert is rejecting writes doesn't tell you why, and "why" is the thing on-call actually needs.

So we tightened the model. We split the tree into two kinds of nodes. A question is something the agent tries to answer with validated evidence. A hypothesis is a claim the agent tries to prove or refute in an effort to answer your question. With that structure in place, the next run didn't stop at "downstream is rejecting writes." It recorded that as a finding, opened a new line of inquiry into vminsert itself, and followed it to the real root cause. For the team, that was the moment it clicked: a tight, well-defined investigation structure produces noticeably better agent work.

The structure kept evolving from there. Early on, a node went straight from findings to closed. That worked when one agent was investigating alone, but not once several agents and engineers were working the same tree. Whoever reached the node first got to decide its fate. So we added assessments as a step before closing. Before a hypothesis is closed, each participant, whether an agent or a person, can post an assessment saying whether the evidence supports or refutes it and why. The node closes only after those views are on the record. If two agents disagree, or the on-call engineer has context neither of them had, you see it before the decision is made, not after.

The investigator is also upfront about what it can't see. If it's digging into a database problem and the relevant integration isn't connected, it flags the missing data instead of quietly guessing around it. That's an invitation for a human to fill the gap, and it tells you what to connect so the next investigation goes further.

A good investigator is only half the system, though. An agent that's eager to find answers is also eager to declare them. That's where the moderator comes in.

The moderator: an LLM-as-a-judge for the investigation

The moderator is an LLM-as-a-judge. It doesn’t do research. Its one job is to evaluate the work other participants submit and decide whether it objectively holds up.

Here’s how that plays out. Agents don’t change the status of anything directly. That applies to our investigator and to your coding agent alike. Instead, they submit proposals, like “this hypothesis is supported” or “this branch can be closed.” A proposal wakes the moderator. It pulls the relevant part of the tree, meaning the node, its children, and the findings attached to them, and judges the proposal against that evidence. It accepts or rejects, with reasons. If it rejects, the agent goes back and does more homework.

The core rule is simple: no statement is accepted as true without supporting evidence. A confident summary with no findings behind it gets rejected, no matter which agent wrote it.

People are the exception. If the engineer on call knows a branch is dead, or already has the root cause, they can change the status themselves without waiting for the moderator. The moderator exists to keep agents honest, not to slow down the humans responsible for the incident. And because every change is attributed, a manual call is on the record, just like everything else in the tree.

A few design choices make this judge worth trusting. They also line up with what the wider field has learned about LLM judges over the past couple of years:

  • The worker never grades itself. The investigator doesn't approve its own conclusions. LLMs tend to favor their own output, so separating the role that produces the work from the role that judges it matters.
  • The hard rules live in code, not in the prompt. Only the moderator has the tools to change a status. Other agents don't just get told not to close things. They simply don't have the tool. Where a deterministic check can do the job, it beats any judge.
  • The questions are narrow. We don't ask the moderator to rate an investigation from 1 to 10. We ask whether specific evidence supports a specific claim. Bounded, yes-or-no judgments like that are where LLM judges are most reliable.
  • It gets calibrated against people. We're dogfooding it on our own incidents first and collecting feedback from our engineers on where it got things right and wrong, before tuning it further.

We'll be honest about one thing. Getting the strictness right is still an experiment. Too loose, and agents publish overconfident conclusions. Too strict, and it rejects reasonable work over and over. We expect to tune it as real investigations come through. The next post goes deeper into the engineering decisions behind it.

With the investigator doing the research and the moderator judging it, there's one piece left: starting investigations without someone having to remember to start them.

Automation that gives you a head start

You choose the monitor issues that matter most, the ones critical enough that whoever is on call should have as much context as possible, as early as possible. When one of those fires, groundcover starts an investigation right away. On-call opens the Slack thread to find hypotheses already in progress and assessments arriving as they land, instead of an empty thread.

Automation comes with guardrails. An admin has to opt the organization in. Automatic investigations then run with the permissions, connectors and AI budget of the person who set up the trigger, and that person confirms it when they save. Nothing runs as an all-seeing system account.

And automation here doesn't mean the investigation runs to completion while you watch from the sidelines. It means you show up to a head start, with the room already set up and the work already moving.

Step in, not step back

Most AI SRE tools ask you to step back and let their agent take over. groundcover Investigations asks you to step in, with your agents and ours already at work, everything consolidated in one shared record, and a judge making sure every claim is backed by evidence. The investigator shows its work, tells you what it can't see, and leaves space for you to steer, push back, or add the context only you have. Next up, we're looking at deploy baselines and CI/CD hooks, so investigations can compare what changed before and after a release. In the meantime, I encourage you to join our community Slack and ask any questions you may have. I also encourage you to give groundcover a try with our playground.

Anais Dotis
Anais Dotis
 

8 min read |
Published on: Nov 15, 2026

Latest posts

Explore related posts

Sign up for Updates

Keep up with all things cloud-native observability.

We care about data. Check out our privacy policy.

No items found.
No items found.
No items found.
No items found.
No items found.
No items found.
No items found.