ResolveX

Autonomous AI that safely resolves IT issues

Comment

Inspiration

Every employee has lived this: a VPN that needs resetting, a payroll access request stuck behind a policy check, a question that requires digging through a wiki nobody updates. None of it is hard — it's just slow, because a human has to walk through the same mechanical steps every single time. Most "AI assistants" for this stop at explaining the runbook and hand the employee back to a ticket queue. We wanted to build something that actually finishes the job — safely.

What it does

ResolveX takes a single natural-language request like "My VPN isn't working and I can't access payroll" and:

  1. Understands it — splitting one sentence into distinct problems.
  2. Plans — builds an execution plan and assigns each problem to a specialist agent.
  3. Delegates — an Orchestrator routes VPN issues to an IT Agent, access requests to an Access Agent, policy questions to a Knowledge Agent.
  4. Acts through governed tools — every agent reaches enterprise systems only through an MCP tool layer (check VPN, reset VPN, grant access, search policy, create a ticket) — never the database directly.
  5. Verifies — a dedicated Verification Agent independently re-checks system state after every action. Nothing is reported "resolved" on an assumption.
  6. Escalates or gates on risk — a four-tier risk engine (LOW/MEDIUM/HIGH/CRITICAL) auto-executes safe actions and routes anything HIGH or CRITICAL to a human Approval Center, with the exact policy evidence attached. Administrator-level actions are architecturally incapable of running without a human.

The result: VPN resets and gets verified in seconds with zero human involvement; payroll access pauses for one human approval and then gets granted and verified automatically the moment it's approved.

How we built it

  • Backend: FastAPI + SQLAlchemy + SQLite, with a clean layering of API → agents → services → an MCP tool layer → database.
  • Agents: five specialist agents (Orchestrator, IT, Access, Knowledge, Verification) implemented as a custom Python orchestrator rather than a heavyweight framework — five agents didn't need the overhead.
  • MCP: a real MCP server built on the official Python MCP SDK (mcp.server.fastmcp), exposing every enterprise tool over stdio so any MCP client can drive the same governed operations, not just this app.
  • Safety: a risk engine that is the single source of truth for what runs automatically vs. what requires a human — LOW/MEDIUM auto-execute and log; HIGH/CRITICAL always pause for approval.
  • LLM: a configurable OpenAI-compatible layer used only to phrase the human-readable summary. All planning, delegation, and safety decisions stay fully deterministic, so the app runs with zero external dependencies in DEMO_MODE.
  • Frontend: Next.js 14 + TypeScript + Tailwind, with four purpose-built views — Employee Chat, a live multi-agent activity timeline, a human Approval Center, and an Admin/System dashboard — because a multi-agent system that hides its own reasoning wastes the best part of a live demo.
  • Deployment: backend on Render, frontend on Vercel, wired together with CORS.

Challenges we ran into

  • Never letting the system lie about success. It was tempting to mark an action "resolved" the moment it was attempted. We built the Verification Agent specifically to close that gap — every mutating action gets independently re-checked before anything is called done.
  • Making autonomy safe without making it useless. Too conservative and the system never does anything on its own; too permissive and it's dangerous. The four-tier risk engine, with CRITICAL actions structurally incapable of auto-executing, was the resolution.
  • Keeping the demo 100% reliable. Live demos with real LLM calls are fragile. We built a fully deterministic DEMO_MODE so the exact same VPN+payroll scenario runs identically every time, with zero network dependency.
  • First deploy on Render's free tier came up with an empty database because the seed step didn't fire correctly on a fresh ephemeral disk after adding an environment variable — a good reminder that "works locally" and "works on a cold-started free-tier container" are different bars.

What we learned

Verification is not optional in agentic systems — it's the difference between an assistant and something you can actually trust with real actions. We also learned that visualizing the agent handoffs (who did what, in what order, with what evidence) matters as much as the automation itself, especially in a live demo where nobody can see your backend logs.

What's next

  • Real Freshworks Agent Studio / MCP integration for ticketing (the interface is already built and mock-backed).
  • Real-time push instead of polling for the live activity feed.
  • Role-based authentication and a persisted, multi-instance-safe approval-resume store.
  • Broader coverage: HR onboarding, software licensing, facilities requests — same orchestrator → specialist → tool → verify loop.

Built With

Share this project:

Updates