ResolveX — Autonomous Employee Operations

An AI agent system that turns employee requests into verified outcomes by orchestrating specialist agents, MCP skills, enterprise knowledge, approvals, and real actions.

Comment

Inspiration

Employees often don't need another chatbot that tells them what to do. They need someone—or something—that can actually get the work done.

We were inspired by the everyday friction employees face with internal services: requesting access, resolving IT issues, understanding HR policies, arranging workplace services, and following up on tickets. A simple request can involve multiple departments, systems, approvals, and repetitive conversations.

We wanted to rethink this experience around one question:

What if an employee could simply describe the outcome they want, and AI could coordinate everything required to achieve it?

That idea became ResolveX — an Autonomous Employee Operations Agent.

Instead of creating another conversational assistant, ResolveX is designed to turn an employee's goal into an executable workflow:

Understand → Plan → Delegate → Execute → Verify → Deliver

What ResolveX Does

An employee can say:

"I'm joining the Chennai office next Monday. Make sure everything is ready for my first day."

ResolveX understands the goal and breaks it into actionable tasks across multiple domains:

  • 💻 IT Agent — laptop, accounts, VPN and software access
  • 👥 HR Agent — onboarding, policies and employee requirements
  • 🏢 Workplace Agent — office access, parking and desk readiness
  • 📚 Knowledge Agent — retrieves relevant company policies and documentation
  • 🔍 Verifier Agent — confirms that actions actually succeeded
  • 🚨 Escalation/Handoff — transfers tasks to the right specialist or human when necessary

The agents use MCP-based reusable skills to interact with enterprise capabilities rather than simply generating text.

For example:

Employee Goal
      ↓
ResolveX Orchestrator
      ↓
Create Execution Plan
      ↓
┌──────────┬──────────┬────────────┐
│ IT Agent │ HR Agent │ Workplace  │
└────┬─────┴────┬─────┴─────┬──────┘
     ↓          ↓           ↓
  MCP Skills  Knowledge   MCP Skills
     ↓          ↓           ↓
     └──────────┼───────────┘
                ↓
          Human Approval
                ↓
            Verification
                ↓
          Final Outcome

The goal is not to make AI appear autonomous. The goal is to make it useful, controlled, and outcome-oriented.

Why We Built It This Way

The project is designed around the capabilities emphasized by the Freshworks Customer & Employee Experience track:

  • AI agents
  • multi-agent orchestration
  • MCP integrations
  • reusable agent skills
  • enterprise knowledge
  • human-in-the-loop workflows
  • intelligent escalation

ResolveX combines these capabilities into a single employee experience.

A traditional support bot might respond:

"Please contact IT to request VPN access."

ResolveX instead checks the employee's context, determines whether VPN access is required, invokes the appropriate skill, requests approval when necessary, executes the action, and verifies the result.

The difference is simple:

A chatbot provides an answer. ResolveX pursues an outcome.

How We Built It

ResolveX uses a modular architecture so that agents, tools, knowledge, and enterprise integrations remain independent.

Agent Orchestration

A central ResolveX Orchestrator receives the employee's natural-language goal and coordinates the specialist agents.

The Planner converts the goal into structured tasks, while the Orchestrator manages:

  • task dependencies
  • parallel execution
  • agent routing
  • handoffs
  • approvals
  • failures
  • verification
  • final resolution

MCP Skills

We designed enterprise capabilities as reusable MCP skills.

Examples include:

check_vpn_status()
request_vpn_access()
check_laptop_status()
search_hr_policy()
check_onboarding_requirements()
check_office_access()
check_parking()
reserve_parking()
create_it_ticket()
search_it_incidents()

This allows agents to discover and use capabilities without tightly coupling business logic to a single agent.

Knowledge & RAG

Company policies and internal documentation are indexed into a knowledge layer using embeddings and vector search.

This allows the Knowledge Agent to retrieve relevant information such as:

  • VPN policies
  • onboarding procedures
  • office access rules
  • parking policies
  • software access policies

The system is designed to ground policy-related responses in actual company documentation rather than allowing the model to invent policies.

Risk-Aware Actions

Not every action should be autonomous.

ResolveX categorizes actions by risk:

Risk Example Handling
Low Check VPN status Automatic
Medium Request standard access Confirmation/approval
High Privileged access Human approval

This gives the system a balance between autonomy and control.

Verification

A major design principle is that an action is not considered complete simply because an API returns successfully.

Instead:

ACTION
  ↓
VERIFY
  ↓
SUCCESS / FAILURE

For example:

request_vpn_access()
        ↓
check_vpn_status()
        ↓
VPN enabled?
        ↓
YES → RESOLVED
NO  → ESCALATE

This makes ResolveX outcome-oriented rather than action-oriented.

Freshworks Integration

ResolveX is designed around the Freshworks ecosystem, with Freshworks Agent Studio serving as an important entry point for the employee experience.

The architecture allows Freshservice and other Freshworks capabilities to be connected through the integration layer.

The resulting flow is:

Employee
   ↓
Freshworks Agent Studio
   ↓
ResolveX Orchestrator
   ↓
Specialist Agents
   ↓
MCP Skills
   ↓
Enterprise Systems
   ↓
Verification
   ↓
Employee Outcome

Where live enterprise credentials are unavailable, we use mock enterprise services behind the same interfaces so the complete agent workflow can be demonstrated without compromising the architecture.

What We Learned

Building ResolveX taught us that agentic AI is much more than connecting an LLM to a chat interface.

We learned how important it is to separate:

  • reasoning from execution
  • agents from tools
  • knowledge from actions
  • autonomous actions from approval-required actions
  • execution from verification

We also learned that multi-agent systems need strong orchestration. Simply creating several agents does not automatically produce a reliable system. Agents need clear responsibilities, structured outputs, permissions, context, handoff protocols, and failure handling.

Most importantly, we learned to design AI around outcomes instead of conversations.

Challenges We Faced

1. Coordinating Multiple Agents

Different tasks can require different specialists, and some tasks depend on others.

We addressed this using a central orchestrator, structured task states, dependencies, and explicit agent handoff protocols.

2. Making AI Actions Safe

Giving an AI agent access to enterprise systems introduces risk.

We implemented risk classification, permissions, approval workflows, and audit logging so that sensitive operations can require human intervention.

3. Preventing Hallucinated Policies

Enterprise policy questions cannot rely solely on an LLM's memory.

We addressed this using a RAG-based knowledge layer that retrieves relevant company documentation before generating policy-related responses.

4. Knowing When a Task Is Actually Complete

An action returning success does not necessarily mean the employee's problem is solved.

We therefore introduced a dedicated verification step after important actions.

5. Designing a Useful Demo

We wanted judges to see the agents actually working rather than watching a static chatbot conversation.

ResolveX therefore exposes a real-time execution timeline showing:

Planner
   ↓
IT Agent
   ↓
HR Agent
   ↓
MCP Tool
   ↓
Approval
   ↓
Agent Handoff
   ↓
Verification
   ↓
Resolution

The Result

ResolveX transforms employee support from a ticket-centric experience into an outcome-centric experience.

Instead of:

"Which department should I contact?"

The employee can simply say:

"Here's what I need to accomplish."

ResolveX determines what needs to happen, coordinates the right agents, uses the right skills, asks for approval when necessary, verifies the result, and escalates when AI should not act alone.

Don't create a ticket. Create an outcome.

Built With

  • agent-handoff
  • agentic-ai
  • ai-agents
  • ai-orchestration
  • enterprise-ai
  • fastapi
  • freshservice
  • freshworks-agent-studio
  • generative-ai
  • human-in-the-loop
  • knowledge-retrieval
  • llm
  • mcp
  • multi-agent-systems
  • pgvector
  • postgresql
  • python
  • rag
  • react
  • tailwind-css
  • tool-calling
  • typescript
  • vector-database
  • websockets
Share this project:

Updates