RESOLVE — AI-Native Enterprise Operations

An AI operations agent that detects incidents, investigates root causes, safely executes remediation, verifies recovery, and escalates high-risk actions to humans.

Comment

Inspiration

Enterprise incidents are rarely difficult because people cannot identify that something is wrong. The difficult part is deciding what to do next, whether an action is safe, and whether the system has actually recovered.

A production incident can involve multiple teams, services, dashboards, tickets, and decisions. An AI assistant that only summarizes the situation is useful, but it still leaves the most important operational decisions to humans.

We wanted to explore a different question:

What if an AI operations agent could take an incident from detection to verified resolution while knowing when it must stop and ask a human?

That idea became RESOLVE — AI-Native Enterprise Operations.

RESOLVE is designed around a simple principle: autonomy should not mean unrestricted access. An agent should investigate, reason about an action, evaluate its risk, execute only what policy allows, independently verify the outcome, and escalate when human judgment is required.

What it does

RESOLVE demonstrates an end-to-end agentic incident response workflow:

Detect → Investigate → Decide → Risk Check → Act → Verify → Resolve or Escalate

When an incident is detected, RESOLVE creates an incident record and begins an investigation.

The Investigation Agent gathers and presents evidence, identifies a likely root cause, and reports its confidence.

The Decision Agent proposes a remediation action together with:

  • Reasoning
  • Expected outcome
  • Risk level
  • Reversibility
  • Supporting evidence
  • Estimated recovery time

Before anything happens, the Policy Engine determines what the agent is actually allowed to do.

For example:

  • A reversible gateway rollback can be AUTONOMOUS
  • A $48,700 customer refund requires HUMAN APPROVAL
  • Deleting production data is BLOCKED

Approved actions are executed through a controlled Tool Gateway, rather than allowing an agent to directly perform unrestricted operations.

After execution, the Verification Agent independently checks the result against the baseline and before/after metrics.

For our primary demonstration incident, the failure rate progresses from:

38.4% → 17.2% → 4.7% → 2.3%

The incident is only marked RESOLVED after successful verification.

If verification fails, or if a human rejects a high-risk action, RESOLVE escalates the incident instead of falsely declaring success.

Every significant decision and action is recorded in an audit trail.

How we built it

We built RESOLVE as an AI-native enterprise operations prototype using a React-based interface and a deterministic state-driven orchestration layer.

The architecture separates the major responsibilities of the system:

  • Detection Agent — identifies and creates incidents
  • Investigation Agent — analyzes evidence and determines probable root cause
  • Decision Agent — proposes remediation
  • Policy Engine — determines whether an action is autonomous, requires approval, or is blocked
  • Action Agent — executes authorized actions
  • Verification Agent — independently verifies recovery
  • Escalation Agent — prepares human-readable escalation summaries
  • Tool Gateway — provides a controlled boundary between agents and operational tools
  • Audit Store — records the operational lifecycle

For Stage 1, connectors are simulated so that the complete workflow can be demonstrated reliably without requiring production credentials or external enterprise systems.

The prototype contains multiple simulated tools with metadata describing permissions, risk, reversibility, input requirements, and verification strategies.

We also implemented deterministic demo scenarios so judges can see the same critical workflows consistently:

  1. Successful autonomous remediation
  2. High-risk action requiring human approval
  3. Human rejection leading to escalation
  4. Blocked destructive action
  5. Verification failure leading to escalation

The interface was designed around an operations command center concept, with dedicated views for incidents, investigation, decisions, execution, verification, approvals, and the final resolution report.

Challenges we ran into

The biggest challenge was not building individual screens. It was making the entire workflow behave like one coherent operational system.

Early in development, we encountered state-management and React integration problems that caused parts of the interface to render without the underlying RESOLVE state being connected correctly.

We also discovered a subtle issue where the initial Launch Demo interaction appeared functional visually but did not actually initialize the demo state correctly.

We fixed these issues by making the state transitions explicit and connecting the interface directly to the RESOLVE state machine.

Another challenge was designing autonomy responsibly.

It is easy to make a demo where an AI agent simply says:

"I fixed the incident."

We wanted RESOLVE to demonstrate something more meaningful.

The system must establish:

Why should this action happen?

Is the agent allowed to perform it?

Was the action actually executed?

Did the system recover afterward?

Should the incident really be considered resolved?

That led us to make policy enforcement, controlled tool execution, independent verification, and human escalation first-class components of the architecture.

Accomplishments that we're proud of

We are particularly proud of building a complete incident lifecycle rather than a standalone AI chat interface.

RESOLVE demonstrates a visible chain of responsibility from detection through verified resolution.

Some of the capabilities we are most proud of include:

  • A complete multi-agent incident lifecycle
  • Deterministic policy enforcement
  • Autonomous versus human-approved decision paths
  • Explicit blocking of dangerous actions
  • Controlled tool execution through a Tool Gateway
  • Independent verification of recovery
  • Verification failure → escalation
  • Human approval and rejection workflows
  • Auditability of important agent decisions
  • A repeatable demonstration environment
  • Automated tests covering the critical lifecycle paths

Most importantly, RESOLVE treats verification as part of the action itself.

An action is not considered successful merely because a tool returned successfully.

The system needs evidence that the underlying incident actually improved.

What we learned

We learned that building an agentic system is less about making an AI model perform more actions and more about designing the boundaries around those actions.

Autonomy needs structure.

A useful enterprise agent needs:

Context → Reasoning → Policy → Action → Verification → Accountability

We also learned that human-in-the-loop design should not be treated as a failure of automation.

For high-impact decisions, asking a human for approval can be the correct behavior.

Finally, we learned that a good agent experience needs to make its decisions visible. Users should be able to understand what the agent discovered, what it intends to do, why it is allowed to do it, what happened, and whether the result was actually verified.

What's next for RESOLVE — AI-Native Enterprise Operations

Stage 1 is a prototype demonstrating the core concept. The next step is turning the simulated operational environment into a real enterprise agent platform.

Our vision is to connect RESOLVE to real enterprise systems through integrations such as Freshworks, MCP-based tools, ticketing systems, observability platforms, communication systems, knowledge bases, and business applications.

Future versions could allow RESOLVE to:

  • Monitor real operational signals
  • Create and update real support incidents
  • Search organizational knowledge
  • Coordinate multiple specialist agents
  • Execute approved remediation workflows
  • Request human approval through enterprise channels
  • Maintain persistent operational memory
  • Learn from previous incidents
  • Provide complete audit and compliance records
  • Adapt its response based on organizational policies

The long-term goal is not simply to build an AI that can operate a business.

It is to build an AI operations system that knows when to act, when to ask, when to stop, and how to prove that the job is actually done.

Built With

  • agentic-ai
  • ai
  • ai-agents
  • automation
  • enterprise-ai
  • human-in-the-loop
  • incident-management
  • mcp
  • multi-agent-systems
  • observability
  • react
  • state-machine
  • typescript
  • vite
  • workflow
Share this project:

Updates