Remy - The Resolution Agent

An AI workforce member for IT that investigates incidents, reasons across enterprise systems, safely remediates under policy, and verifies resolution with the employee.

Comment

Inspiration

Enterprise IT is moving from AI assistants toward an AI workforce — digital workers that can take ownership of operational tasks, not simply provide recommendations.

We asked: What would an AI worker for IT resolution actually look like?

Today, an employee who loses access to an application can trigger a surprisingly manual process. An IT engineer may need to investigate identity, entitlements, recent changes, device state, application state, and previous incidents across multiple systems. Even after finding the cause, the engineer still has to decide whether the fix is safe to execute and, in many cases, verify with the employee that the problem was actually resolved.

We wanted to build an agent that could own this entire resolution loop.

That became Remy — The Resolution Agent.

Our goal was not to build another IT chatbot that answers questions or deflects tickets. We wanted Remy to investigate, reason, act within enterprise policy, and remain accountable for the outcome.

What it does

Remy is an autonomous IT resolution agent that works alongside Freshservice to take an incident from investigation to verified resolution.

We designed the workflow around seven stages:

Intake → Diagnose → Reason → Policy Gate → Remediate → Voice Verify → Resolution

When an incident arrives, Remy first understands the employee's problem and gathers the necessary context.

It then investigates multiple systems in parallel, including:

  • Identity and account state
  • User entitlements and roles
  • Recent changes and department transfers
  • Device and asset state
  • Previous incident history

Instead of stopping at the first plausible explanation, Remy correlates the evidence and produces a stated root cause, confidence level, supporting evidence, and the alternatives it ruled out.

Once it knows what needs to be changed, Remy does not automatically execute every action. The proposed remediation passes through a policy gate that evaluates scope and risk. If approval is required, the evidence and proposed action are presented to the appropriate approver.

After approval, Remy performs the specific remediation and records the action against the incident.

The final step is what makes Remy different: verification.

Remy contacts the employee through voice and asks them to try the application again. If the employee confirms that the issue is resolved, Remy closes the incident with the investigation, approval, remediation, and verification evidence attached. If the employee says the problem persists, the incident is reopened and escalated with the new information.

Remy therefore treats "the employee confirmed it works" as the definition of resolution — not simply "the backend action succeeded."

How we built it

We designed Remy around a read-broad, write-narrow architecture.

The investigation layer can gather evidence from multiple enterprise systems, while remediation is deliberately restricted to specific approved actions.

Our prototype uses:

  • Freshworks Agent Studio + MCP for agent orchestration, tool access, and Freshservice interactions
  • Freshservice as the system of record for incidents, approvals, changes, and audit history
  • ElevenLabs for the outbound verification call and transcription
  • Mocked identity, HRIS, and Salesforce systems for deterministic stage demonstration

The prototype demonstrates a complete end-to-end scenario:

An employee cannot access Salesforce after changing departments.

In this scenario, Remy correlates the evidence and identifies that the employee's Salesforce entitlement was removed following the department transfer. It proposes restoring the specific missing role, sends the action through the policy gate, performs the approved remediation, and then calls the employee to verify the result.

The architecture intentionally separates reasoning from authority. The agent can propose an action, but the policy layer determines whether that action can execute or requires human approval. This allows enterprise autonomy to be governed without changing the agent's reasoning itself. :contentReference[oaicite:2]{index=2}

Challenges we ran into

The hardest part was not making an agent generate an answer. It was designing an agent that could take action responsibly.

1. Making the reasoning auditable

A simple "root cause: entitlement revoked" is not enough for enterprise IT.

Remy needs to show the evidence supporting the conclusion and the alternatives that were eliminated. This led us to design an evidence-driven reasoning flow rather than treating the LLM's conclusion as a black box. :contentReference[oaicite:3]{index=3}

2. Giving an AI controlled authority

An autonomous agent cannot have unrestricted write access to enterprise systems.

We therefore separated the agent's reasoning from the policy decision. Remy proposes the remediation, while the policy gate determines whether it can execute or requires approval. :contentReference[oaicite:4]{index=4}

3. Making verification meaningful

We did not want to consider a ticket resolved just because an API returned success.

The verification step had to come from the person experiencing the problem. This led us to make voice verification a structural part of the workflow rather than an additional feature. :contentReference[oaicite:5]{index=5}

4. Making the demo reliable

Because a live hackathon demonstration cannot depend on unpredictable external enterprise systems, we designed deterministic mocked endpoints for identity, HRIS, and Salesforce while keeping the end-to-end resolution journey intact. :contentReference[oaicite:6]{index=6}

Accomplishments that we're proud of

We are most proud that Remy is designed around outcome ownership, rather than simply automating individual IT tasks.

We built a complete resolution journey where:

Evidence → Reasoning → Policy → Action → Human Verification → Resolution

is connected end to end.

We are particularly proud of three aspects:

  • Evidence-based reasoning: Remy explains why it believes a particular cause is responsible instead of simply returning an answer.
  • Governed autonomy: Remy can take action while keeping enterprise policy and human approval in the loop when required.
  • Closed-loop resolution: Remy independently verifies the outcome with the employee and can reopen and escalate the incident if the fix did not work.

The result is an IT agent that does not stop when it finds an answer or executes an action. It stays responsible until the outcome is verified. :contentReference[oaicite:7]{index=7}

What we learned

Building Remy changed how we think about enterprise agents.

We learned that the difficult part of an autonomous agent is not just intelligence — it is trust.

For an enterprise AI worker to take action, three things need to work together:

  1. Reasoning — it must understand why an action is appropriate.
  2. Governance — it must operate within clearly defined authority.
  3. Accountability — it must know whether the action actually solved the user's problem.

We also learned that verification is more than a user-experience feature. It creates an independent signal about whether the system's action produced the intended real-world outcome.

This shaped Remy's core principle:

Don't just execute the fix. Own the resolution.

What's next for Remy - The Resolution Agent

Our prototype focuses on one complete IT resolution scenario, but the same resolution loop can extend to a much broader set of enterprise incidents.

Next, we want to:

  • Expand Remy's connector ecosystem across identity, HR, endpoint management, SaaS applications, and IT operations.
  • Support more remediation actions while keeping every action governed by policy.
  • Improve confidence and evidence scoring for complex multi-system incidents.
  • Expand voice verification into a broader employee interaction layer.
  • Learn from previous verified resolutions to improve future investigations.
  • Extend Remy from individual incident resolution toward a broader AI workforce for enterprise IT operations.

Our long-term vision is simple:

IT should not need another assistant that tells people what to do. It needs AI workers that can safely take ownership of the work — and prove when it is actually done.

Built With

  • agentic-ai
  • ai
  • ai-agents
  • ai-governance
  • change-management
  • css
  • enterprise
  • freshservice
  • freshworks
  • generative-ai
  • html
  • itsm
  • javascript
  • python
Share this project:

Updates