Skip to content
Research2026

HPE OpsNexus

Enterprise Operations Intelligence Mesh

Architect & Lead Engineer HPE Operations: Engineering, Cloud, Infrastructure, Supply Chain & Finance Knowledge graphs & decision calibration

🏆 HPE FOCUS AI Ideathon 2026 – Winner (Ranked #1)

A reasoning layer above HPE's existing operational systems that predicts the downstream business impact of a change before anyone commits to it.

A six-layer intelligence mesh that federates 15 enterprise systems through their published APIs, builds an enterprise knowledge graph plus a persistent operational memory, reasons across domains with a LangGraph agent layer over Azure AI Search, and delivers explainable, confidence-scored recommendations into Teams rather than a new portal.

Engineering Brief

My contribution
System design, the knowledge and memory graph architecture, agent orchestration, and the Phase-1 pilot plan.
Engineering difficulty
Reason across operational domains without replacing source systems or bypassing their access boundaries.
Outcome
Research proposal with a scoped pilot. Decision-speed and analysis-effort improvements are targets, not measured results.
Inspect architectureEvidence & scope Portfolio context
Engineering questions

The Problem

Every function runs its own tooling, dashboards and AI, so teams spend an estimated 60–70% of analytical effort assembling context before deciding anything. A major GPU procurement can move through six functions with every dashboard green and still land hardware before capacity is ready. The failure is not execution; it is that nothing reasons across the domain boundaries.

System Architecture

Enter system environment

Architecture design

Illustrative paths, not live telemetry.

Existing enterprise systems feed a knowledge and memory graph that agents reason over, producing impact predictions delivered into Teams, and every outcome is written back.

Architecture overview. No node selected.

Full network reference
  • Enterprise Systems

    ServiceNow · OpsRamp · SAP

    Kind: external

    Published enterprise APIs are the proposed input boundary. The wider integration design is separate from the narrow Phase-1 pilot.

    Incoming (0)

    None in this diagram

    Outgoing (1)

  • Telemetry & Events

    Logs · metrics · changes

    Kind: ops

    Operational logs, metrics and changes provide context for cross-domain reasoning.

    Incoming (0)

    None in this diagram

    Outgoing (1)

  • Connectivity Layer

    Normalize · RBAC at ingest

    Kind: api

    Normalize incoming records and attach entitlement metadata before graph and retrieval ingestion.

  • Agent Orchestration

    LangGraph · MCP tools

    Kind: agent

    Coordinate the planner, registered MCP tools and durable reasoning steps, with human approval as an explicit gate.

    Incoming (2)

    Outgoing (1)

  • Knowledge + Memory

    Neo4j · dependencies

    Kind: data

    Connect assets, services and dependencies with a memory of prior decisions, fixes and outcomes.

    Incoming (2)

    Outgoing (2)

  • Decision Intelligence

    Impact · confidence

    Kind: service

    Combine graph reasoning and retrieved context into an impact prediction with evidence and a confidence score.

    Incoming (2)

    Outgoing (1)

  • Teams / Cockpit

    Explainable actions

    Kind: client

    Surface explainable recommendations in Teams rather than requiring another operational portal.

    Incoming (1)

    Outgoing (1)

  • Learning Loop

    Outcomes · overrides

    Kind: ml

    Feed outcomes and overrides back into operational memory. This is a design loop, not live telemetry from HPE.

    Incoming (1)

    Outgoing (1)

What I Engineered

  • Architected a six-layer mesh that federates 15 enterprise systems (ServiceNow, OpsRamp, GreenLake, Azure, Kubernetes and SAP among them) through their published APIs, with zero changes to any system of record.
  • Designed the organizational intelligence layer: an enterprise knowledge graph of assets, services and dependencies, paired with an operational memory graph of decisions, actions, fixes and outcomes.
  • Specified a LangGraph orchestration layer with a planner, an MCP tool registry, durable multi-step workflows and an explicit human-in-the-loop approval gate as an architectural component, not a UI courtesy.
  • Built the decision-intelligence layer on graph reasoning plus Azure AI Search, returning predicted business, SLA and cost impact alongside the reasoning path, the linked evidence and a calibrated confidence score.
  • Made calibration a release gate rather than a report: predictions must hold an expected calibration error of 0.10 or better, so a stated confidence means what it says.
  • Scoped a deliberately narrow Phase-1 pilot: change-impact reasoning over ServiceNow + CMDB inside one organisation, with defined KPI gates and pivot/kill criteria before any expansion.

Impact & Scale

Project references

  • Ranked #1 of all submissions in HPE's FOCUS AI Ideathon 2026
  • Advanced to final review before the FOCUS Group leadership panel
  • Phase-1 pilot scoped to two systems and one workflow: no new data platform, no migration
Ideathon#1 of all entries
Federated systems15 enterprise
CalibrationECE ≤ 0.10

Targets, not yet measured

  • 40% faster decisions and 60% less manual analysis, gated over an 8-week pilot
  • Aimed at the ~65% of engineering effort HPE currently spends assembling context

Evidence & Scope

Architecture, engineering decisions, and the Phase-1 pilot plan are documented in this case study.

Source and internal telemetry are HPE-internal. Architecture, trade-offs and the pilot measurement plan walked through on request.

Engineering Decisions

  1. 01

    Consumed the existing systems of record instead of building a new data platform.

    Reading GreenLake, OpsRamp, ServiceNow and SAP through their published APIs avoids replacing the systems of record. Connector development, entitlement mapping and operational support still require engineering work; the design reuses existing platforms rather than introducing a competing data platform.

  2. 02

    Paired vector retrieval with graph traversal rather than shipping a plain RAG assistant.

    Vector search finds semantically similar things; graph traversal finds causally connected ones. Vector-only cannot answer what a change affects three hops away, and graph-only cannot read runbooks, tickets and email. Cross-domain operational reasoning needs both, so the hybrid is the technical core of the design.

  3. 03

    Captured entitlement metadata at ingestion instead of filtering only at query time.

    If access control is applied late, retrieval can assemble an answer from records the requester is not entitled to see. Binding entitlement metadata at ingestion supports permission-aware retrieval, but enforcement still depends on correct query-time checks, current permissions and tested policies.

  4. 04

    Delivered recommendations into Teams instead of building another dashboard.

    Adoption is the real risk on a layer like this, and a portal nobody opens produces no measurable benefit no matter how good the reasoning is. Arriving where people already work is what makes the pilot measurable at all.

Stack

Neo4j
Represent assets, dependencies and operational memory as connected records.
Azure AI Search
Retrieve unstructured operational context alongside graph relationships.
LangGraph
Coordinate multi-step reasoning with an explicit human approval gate.
MCP
Give the orchestration layer a defined interface to its registered tools.
LangGraphAzure OpenAINeo4jKnowledge GraphsAzure AI SearchRAGMCPFastAPIPostgreSQL

Source and internal telemetry are HPE-internal. Architecture, trade-offs and the pilot measurement plan walked through on request.

Related work

Shared engineering patterns across separate systems, not runtime dependencies.

  • Hexus – Smart Log Manager

    Both place controls around model-assisted reasoning: OpsNexus proposes permission-aware graph and vector retrieval, while Hexus documents guarded RCA and ingestion-time redaction.

    Enterprise Internal

  • RapidDoc AI

    Both make system relationships explicit before synthesis: OpsNexus proposes traversal of an operational graph alongside retrieval; RapidDoc extracts dependencies and call relations from code.

    Production Pilot

Open to AI Software Development & Platform Engineering roles

Need someone who ships systems like this into production?