Enterprise Internal2026

Agentic AIOps Blueprint

Intelligent ITSM & Infrastructure Mapper

AI Software Development Engineer Enterprise IT Operations & ITSM Deterministic topology extraction

A multi-agent system that reads live infrastructure and auto-generates compliant ITSM design and operational documents.

An infrastructure-mapping platform whose agents parse Terraform and Kubernetes manifests, trace CI/CD and data flows, and emit ITSM-compliant SOPs, Low-Level Designs and Microsoft Word deliverables, folded into CI so the documentation regenerates on every infrastructure change.

Engineering Brief

My contribution
Infrastructure parsing, topology-to-LLD mapping, agent-assisted authoring, CI integration, and Word deliverable generation.
Engineering difficulty
Preserve traceability to actual infrastructure while producing documents in the formats used by ITSM reviewers.
Outcome
An internal documentation workflow with reduced runbook preparation time and fewer approval rejections.
Inspect architectureRun local demoEvidence & scope Infrastructure to document Portfolio context
Engineering questions

The Problem

Bridging MLOps environments to enterprise ITSM compliance was manual and error-prone: runbooks took days to write and approvals were frequently rejected for inaccurate topology.

System Architecture

Enter system environment

Architecture design

Illustrative paths, not live telemetry.

IaC and CI/CD signals feed an agentic mapper that synthesises LLDs, SOPs and compliant Word docs, driving down ITSM rejections.

Architecture overview. No node selected.

Full network reference

  • IaC / K8s

    Configs

    Kind: cloud

    Terraform and Kubernetes manifests supply resource definitions instead of manually maintained topology descriptions.

    Incoming (0)

    None in this diagram

    Outgoing (1)

  • CI/CD Pipelines

    Data flows

    Kind: ops

    Infrastructure changes trigger regeneration of operational handover artifacts.

    Incoming (0)

    None in this diagram

    Outgoing (1)

  • Topology Ingest

    Parser

    Kind: api

    Deterministic parsers extract resource relationships before an agent authors the document.

    Incoming (2)

    Outgoing (1)

  • Agentic Mapper

    LangGraph

    Kind: agent

    Coordinate topology-to-document mapping while keeping generated prose traceable to extracted structure.

    Incoming (1)

    Outgoing (3)

  • Infra → LLD

    Design docs

    Kind: service

    Turn the extracted infrastructure graph into a Low-Level Design document.

    Incoming (1)

    Outgoing (1)

  • SOP / SOW Gen

    Runbooks

    Kind: service

    Generate operational runbooks, SOPs and SOWs from the mapped infrastructure context.

    Incoming (1)

    Outgoing (1)

  • Compliance Fmt

    MS Word

    Kind: ops

    Format deliverables for the Microsoft Word templates used in ITSM reviews.

    Incoming (1)

    Outgoing (1)

  • ITSM

    Approvals

    Kind: external

    The generated artifacts enter the existing approval process; the local demo does not submit real approvals.

    Incoming (3)

    Outgoing (0)

    None in this diagram

Live Demo

Follow infrastructure into a document: flow and evidence

A bounded browser parser and local templates produce this captured document. Source architecture links describe the project; no live agent, model, repository or ITSM system is called.

  1. Read the manifest

    Capture the Kubernetes or Terraform fixture and identify resource blocks. The same immutable result is shared with the original demo console. The highlighted components identify the corresponding source responsibilities.

  2. Map relationships

    Inspect resource references and dependencies from the bounded parser. The same immutable result is shared with the original demo console. The highlighted components identify the corresponding source responsibilities.

  3. Assign responsibilities

    Group resources into compute, network, data, security and observability. The same immutable result is shared with the original demo console. The highlighted components identify the corresponding source responsibilities.

  4. Review local checks

    Inspect the fixture's policy findings, including exposure, limits and access hints. The same immutable result is shared with the original demo console. The highlighted components identify the corresponding source responsibilities.

  5. Assemble the LLD

    Build the local design sections from the extracted resource graph. The same immutable result is shared with the original demo console. The highlighted components identify the corresponding source responsibilities.

  6. Inspect the deliverable

    Review the generated design and operational handover content. The output is ready for inspection. This browser demonstration does not commit files or submit an approval.

This local demo requires JavaScript. The architecture and case study remain available above.

What I Engineered

  • Spearheaded an infrastructure-mapping platform whose coordinated agents bridge MLOps environments and enterprise ITSM compliance.
  • Built an engine that parses Terraform and Kubernetes manifests, including pod configs, to auto-generate operational SOPs, runbooks and SOWs.
  • Developed Infrastructure-to-LLD mapping that traces CI/CD pipelines and distributed data flows into ITSM-compliant Low-Level Design docs.
  • Paired deterministic infra parsing with LLM-assisted authoring so every generated LLD stays traceable to the real resource graph.
  • Folded documentation into CI so ops handover artifacts regenerate on every infrastructure change instead of drifting from live infrastructure.
  • Automated generation of compliant Microsoft Word deliverables, eliminating manual formatting overhead for ITOps.

Impact & Scale

Project references

  • Accelerated deployment-to-production timelines by 35%
  • Cut runbook creation from days to under 10 minutes per deployment
  • Reduced ITSM approval rejection rates by over 90% via accurate topology mapping
  • Eliminated 100% of manual compliance-formatting overhead
Deploy time−35%
RunbookDays → <10 min
Rejections−90%

Evidence & Scope

The local manifest-to-LLD demo uses a deterministic fixture. Architecture and engineering decisions describe the infrastructure-to-document workflow.

Source is HPE-internal and cannot be published. Architecture and trade-offs walked through on request.

Engineering Decisions

  1. 01

    Derived design from live IaC and Kubernetes state, not the CMDB.

    ITSM approvals were being rejected for inaccurate topology. Reading the actual Terraform and Kubernetes manifests, the real source of truth, removed the drift that documentation-based mapping always accumulates.

  2. 02

    Extracted topology with deterministic parsers before the agent reasons over it.

    Structure is parsed by code and handed to the LLM as verified facts, so the agent reasons over real infrastructure instead of inventing components. Non-determinism is confined to synthesis, never to what exists.

  3. 03

    Emitted native, compliant Word / SOP artifacts in the exact format ITSM already requires.

    Compliance reviewers live in fixed Word templates. Generating those deliverables directly eliminated manual reformatting entirely, a larger operational win than asking an org to adopt a new tool.

Stack

Python
Extract topology deterministically before language-model authoring.
Terraform
Use infrastructure definitions as an input rather than relying on manually maintained documentation.
LangGraph
Coordinate topology mapping and document-generation agents.
CI/CD
Regenerate operational documents when infrastructure changes.
Multi-Agent SystemsLangGraphAzure OpenAITerraformKubernetesInfrastructure-as-CodeCI/CDPythonITSM

Source is HPE-internal and cannot be published. Architecture and trade-offs walked through on request.

Related work

Shared engineering patterns across separate systems, not runtime dependencies.

This project in the AtlasCompare connected systems
  • RapidDoc AI

    Both extract structure deterministically before language-model authoring: infrastructure manifests for AIOps, code ASTs and dependencies for RapidDoc. Generated documents still need review.

    Production Pilot

    Project references

Open to AI Software Development & Platform Engineering roles

Need someone who ships systems like this into production?

Get in touch Résumé All projects