AI Agent Platform — Multi-Agent DevOps Automation

What Is This?

A multi-agent system where specialized AI agents collaborate to automate DevOps tasks:

• Infrastructure Review — Analyzes Terraform/K8s configs for best practices and misconfigurations
• Security Scanning — Scans code for OWASP Top 10 vulnerabilities, hardcoded secrets, and insecure patterns
• Documentation Generation — Produces clear technical documentation from code analysis results
• Incident Response — Triages alerts, identifies root causes, and suggests remediation steps

Each agent has a distinct role, tools, and backstory — mirroring how real engineering teams divide responsibilities. CrewAI orchestrates their collaboration so tasks flow in dependency order, with outputs from one agent feeding into the next.

Why I Built This

I have production experience building agentic workflows with n8n (low-code), but needed to demonstrate:

1. Python-native agent orchestration — Programmable, not drag-and-drop
2. Testable agent systems — Every agent, tool, and crew has unit tests
3. Versionable AI workflows — Git-friendly code, not JSON configs
4. Production patterns — Structured logging, Pydantic models, error handling, Docker deployment

This project proves I can design and build multi-agent systems from scratch using industry-standard Python tooling.

Architecture

graph TD
    CLI[CLI Entrypoint<br/>src/main.py] --> CREW[DevOps Crew<br/>Orchestrator]

    CREW --> INFRA[Infra Review Agent<br/>Senior Infrastructure Engineer]
    CREW --> SEC[Security Agent<br/>Application Security Engineer]
    CREW --> DOCS[Docs Agent<br/>Technical Documentation Specialist]
    CREW --> INC[Incident Agent<br/>SRE / Incident Response Engineer]

    INFRA -->|findings| SEC
    SEC -->|vulnerabilities| DOCS
    SEC -->|critical issues| INC
    INFRA -->|config analysis| DOCS

    INFRA --- T1[Terraform Analysis Tool<br/>K8s Config Tool]
    SEC --- T2[Code Security Scan Tool<br/>File Reader Tool]
    DOCS --- T3[File Writer Tool]
    INC --- T4[Log Analysis Tool]

    LLM[AWS Bedrock<br/>Claude Sonnet] -.->|LLM calls| INFRA
    LLM -.-> SEC
    LLM -.-> DOCS
    LLM -.-> INC

    style CREW fill:#4a90d9,stroke:#333,color:#fff
    style INFRA fill:#50c878,stroke:#333,color:#fff
    style SEC fill:#ff6b6b,stroke:#333,color:#fff
    style DOCS fill:#ffa500,stroke:#333,color:#fff
    style INC fill:#9b59b6,stroke:#333,color:#fff
    style LLM fill:#333,stroke:#666,color:#fff

Task Dependency Flow

infra_review_task
       │
       ▼
security_scan_task ──► incident_response_task
       │
       ▼
docs_generation_task

Technology Stack

| Component | Technology | Purpose | |-----------|-----------|---------| | Agent Framework | CrewAI | Multi-agent orchestration with roles, goals, and delegation | | LLM Provider | AWS Bedrock (Claude) | Foundation model for agent reasoning | | LLM Abstraction | LangChain | Unified LLM interface + tool integration | | Config Management | Pydantic Settings | Type-safe environment configuration | | Logging | structlog | Structured JSON logging for observability | | Testing | pytest + pytest-asyncio | Unit and integration testing | | Containerization | Docker + Compose | Reproducible deployment | | Package Manager | uv / pip | Fast Python dependency management |

Project Structure

AI-Agent-Platform/
├── src/
│   ├── __init__.py
│   ├── config.py                 # Pydantic Settings — env var loading
│   ├── main.py                   # CLI entrypoint
│   ├── agents/
│   │   ├── __init__.py
│   │   ├── infra_reviewer.py     # Terraform/K8s review agent
│   │   ├── security_scanner.py   # OWASP vulnerability scanner agent
│   │   ├── docs_generator.py     # Documentation generation agent
│   │   └── incident_responder.py # Incident triage agent
│   ├── tools/
│   │   ├── __init__.py
│   │   ├── terraform_tools.py    # IaC analysis tools
│   │   └── code_tools.py         # Code scanning tools
│   └── crews/
│       ├── __init__.py
│       └── devops_crew.py        # Main crew definition + task wiring
├── tests/
│   ├── __init__.py
│   ├── test_agents.py
│   ├── test_tools.py
│   └── test_crew.py
├── sample_configs/
│   ├── sample.tf                 # Terraform with intentional issues (demo)
│   └── sample.py                 # Python with intentional vulns (demo)
├── docker-compose.yml
├── Dockerfile
├── Makefile
├── pyproject.toml
├── .env.example
└── .gitignore

How to Run Locally

Prerequisites

• Python 3.12+
• AWS credentials configured (for Bedrock access)
• Docker (optional, for containerized runs)

Quick Start

# 1. Clone and install
git clone https://github.com/yourusername/AI-Agent-Platform.git
cd AI-Agent-Platform
make install

# 2. Configure environment
cp .env.example .env
# Edit .env with your AWS credentials and Bedrock model ID

# 3. Run against sample configs (demo mode)
make dev

# 4. Run against your own code
python -m src.main ./path/to/your/project

# 5. Run tests
make test

Docker

# Build and run
make docker-build
make docker-run

# Or with docker-compose
docker-compose up

Example Output

$ python -m src.main ./sample_configs/

2025-06-15 10:23:01 [info] Starting DevOps Crew analysis target=./sample_configs/
2025-06-15 10:23:01 [info] Initializing agents count=4

═══════════════════════════════════════════════════════════
  Agent: Senior Infrastructure Engineer
  Task:  Review infrastructure configuration
═══════════════════════════════════════════════════════════

[Infra Review Agent] Analyzing Terraform files...
  ⚠ WARN: S3 bucket missing server-side encryption (sample.tf:12)
  ⚠ WARN: Security group allows 0.0.0.0/0 on port 22 (sample.tf:24)
  ✓ OK:   VPC has flow logging enabled
  ✗ FAIL: No lifecycle policy on resources

═══════════════════════════════════════════════════════════
  Agent: Application Security Engineer
  Task:  Perform security analysis
═══════════════════════════════════════════════════════════

[Security Agent] Scanning codebase...
  ✗ CRITICAL: Hardcoded AWS secret key detected (sample.py:5)
  ✗ HIGH: SQL injection via string formatting (sample.py:18)
  ⚠ MEDIUM: Use of eval() on user input (sample.py:25)

═══════════════════════════════════════════════════════════
  Crew Result: 3 critical, 2 warnings, 1 passed
═══════════════════════════════════════════════════════════

Key Engineering Decisions

Why CrewAI over LangGraph?

CrewAI provides role-based agent design out of the box — each agent has a role, goal, and backstory that shapes its behavior. LangGraph is more flexible but requires building orchestration from scratch. For a DevOps automation use case where agents map to real team roles (SRE, Security Engineer, etc.), CrewAI's opinionated structure is a better fit and produces cleaner, more maintainable code.

Agent Memory Patterns

Agents use CrewAI's built-in short-term memory (conversation context within a crew run) and long-term memory (persistent learnings across runs). This means the security agent can learn from past scans — if it previously identified a pattern as a false positive, it remembers that in future runs.

Error Handling Approach

Each tool wraps operations in try/except and returns structured error messages rather than crashing the crew. Agents are configured with allow_delegation=False for predictable task routing. The crew uses max_rpm to rate-limit LLM calls and avoid API throttling.

Structured Logging

All components use structlog for JSON-formatted logs. This enables log aggregation in production (CloudWatch, Datadog, etc.) and makes debugging agent interactions traceable — every agent action, tool call, and LLM request is logged with context.

Skills Demonstrated

| Skill | Evidence | |-------|----------| | Python AI/ML Engineering | CrewAI agents, LangChain tools, Pydantic models | | Cloud Platform (AWS) | Bedrock LLM integration, IAM-aware security scanning | | Infrastructure as Code | Terraform/K8s analysis tooling, IaC best-practice checks | | Security Engineering | OWASP-aware scanning, secrets detection, CVE patterns | | DevOps / SRE | Incident response automation, Docker deployment, CI/CD ready | | Software Engineering | Type hints, structured logging, pytest, clean architecture | | System Design | Multi-agent orchestration, task dependencies, memory patterns |

Built by Eric Nguyen — Cloud Platform Engineer targeting AI Platform Engineering roles.