Introduction
Cloud infrastructure engineering requires more than writing Terraform code or deploying cloud resources.
Engineers need to interpret requirements, design architectures, review security controls, validate configurations, assess risks, and coordinate deployments.
With the emergence of agentic AI, I wanted to explore a practical question:
Can multiple specialised AI agents collaborate on Azure infrastructure engineering tasks while maintaining security, traceability, and human control?
This project is my attempt to explore that question through a hands-on engineering prototype.
Project Overview
Azure AI Infrastructure Engineer is an experimental multi-agent system designed to assist with Azure infrastructure engineering workflows.
The objective is not to replace cloud engineers or hand over unrestricted cloud access to an AI model.
Instead, the project explores how AI can assist engineers with analysis, design, Infrastructure as Code generation, security reviews, and deployment preparation.
The prototype will be developed progressively using a personal Azure lab environment.
Target Capabilities
The planned system will explore six capabilities:
- Discover and analyse Azure infrastructure.
- Translate natural-language requirements into architecture specifications.
- Generate Terraform configurations.
- Review infrastructure security and compliance.
- Prepare deployment plans for human approval.
- Validate infrastructure after an authorised deployment.
These capabilities represent project goals, not claims that the implementation is already complete.
High-Level Architecture
The system uses an orchestrator coordinating specialised agents.
User Requirements | vClaude Orchestrator | +-- Architect Agent | +-- IaC Engineer Agent | +-- Security Reviewer Agent | +-- DevOps Engineer Agent | +-- Validation Engineer Agent | vControlled Tools and MCP Interfaces | +-- Azure Resource Graph / Azure SDK +-- Terraform Validation and Planning +-- Security Scanning | vIndependent Human Approval Gate | vIsolated Deployment Runner | vPost-Deployment ValidationThe diagram illustrates the proposed architecture. The final implementation may evolve as the labs progress.
Why Multi-Agent Architecture?
A single AI agent could theoretically perform several of these tasks, but separating responsibilities creates opportunities for clearer boundaries and independently reviewable outputs.
For example:
- Architect Agent: Produces structured Azure architecture specifications.
- IaC Engineer: Translates approved specifications into Terraform.
- Security Reviewer: Assesses configurations against defined controls.
- DevOps Engineer: Prepares CI/CD and deployment workflows.
- Validation Engineer: Checks expected infrastructure state and outcomes.
The orchestrator manages task delegation and collects the results from these specialist workflows.
This design does not guarantee correctness. Each output still requires deterministic checks and, where appropriate, human review.
Technology Stack
| Component | Technology |
|---|---|
| AI orchestration | Claude Agent SDK |
| Tool integration | Model Context Protocol |
| Application runtime | Python |
| Cloud platform | Microsoft Azure |
| Infrastructure as Code | Terraform |
| Cloud inventory | Azure Resource Graph |
| Security scanning | Checkov and Azure Policy |
| CI/CD | GitHub Actions |
Technology choices may change based on implementation results and compatibility with the selected SDK versions.
Security and Deployment Guardrails
Safety is a core part of the prototype.
The initial implementation will operate in read-only mode, with scoped Azure access wherever possible.
Infrastructure changes must not be triggered directly by untrusted model output.
The planned deployment workflow requires:
- Least-privilege permissions.
- Deterministic Terraform validation.
- Security scanning and policy checks.
- Review of a saved Terraform plan.
- Human approval enforced outside the model.
- Controlled execution in an isolated runner.
- Logging and post-deployment verification.
Production subscriptions are outside the scope of the initial experiments.
Eight-Week Implementation Roadmap
| Week | Engineering Lab |
|---|---|
| 1 | Development Environment and Agent SDK |
| 2 | Azure Discovery Agent |
| 3 | Multi-Agent Orchestration |
| 4 | Terraform Engineering Agent |
| 5 | Security and Compliance Review |
| 6 | Controlled Deployment Workflow |
| 7 | CI/CD, Logging and Observability |
| 8 | End-to-End Evaluation and Capstone |
Each lab will document the architecture, implementation, testing approach, observed results, costs and limitations.
What Success Looks Like
By the end of the project, the target is a working lab prototype that can take an infrastructure requirement through a controlled engineering workflow.
Success will not be measured by how autonomous the system appears, but by whether its outputs are useful, testable, secure, and repeatable.
The evaluation will include normal scenarios, invalid requirements, failure handling and attempted approval bypasses.
Follow the Project
For the complete learning path and implementation notes, visit the Azure AI Infrastructure Engineer documentation.
You can also explore the project overview.
This article introduces the project. Subsequent lab posts will contain implementation details and verified results.