AI_agents
AI_agents

🧩 Project Story — Multi‑Agent‑DevOps‑Gemini

🌟 Inspiration

Modern DevOps teams are overwhelmed by routine operational work: planning, tracking progress, analyzing risks, reviewing architectures, debugging pipelines, and generating reports.

Most existing “AI DevOps tools” are essentially single chatbots with oversized prompts — fragile, opaque, and hard to trust in production.

This project was inspired by a simple question:

What if DevOps automation followed the same principles as real engineering teams — clear roles, accountability, observability, and long‑running ownership of tasks?

Multi‑Agent‑DevOps‑Gemini was built to demonstrate a gold‑standard multi‑agent architecture where each agent has a well‑defined responsibility, transparent reasoning, and production‑ready behavior — not prompt chaos.

🤖 What it does

Multi‑Agent‑DevOps‑Gemini is an intelligent multi‑agent system that automates core DevOps workflows using Google Gemini 3.

It provides:

Strategic planning and task decomposition
Architecture diagram analysis (vision + reasoning)
Risk and compliance assessment
Progress and velocity tracking
Autonomous code generation, testing, and debugging
Long‑running tasks with persistent state
Human‑readable technical digests
Observability via metrics and health monitoring

All of this is handled by 9 specialized agents, orchestrated via n8n, communicating through a unified MCP protocol.

The result is not a chatbot — but an AI DevOps assistant team.

🏗️ How we built it

The system is built as a distributed microservice architecture:

9 independent agents, each running as a FastAPI service in its own Docker container
n8n acts as the workflow orchestrator, enabling parallel execution, branching logic, and retries
Google Gemini 3 is used for:
- Text reasoning
- Long‑context planning
- Vision‑based architecture analysis
MCP (Model Context Protocol) ensures structured, auditable communication between agents

Each agent exposes:

/health endpoint
/mcp tool interface
Structured reasoning steps
Unified logging

Special focus was placed on:

Observability (metrics, health checks)
Failure isolation
Deterministic outputs
Reproducibility

This aligns with both Marathon Agent (long‑running tasks with state) and Vibe Engineering (autonomous iteration and self‑correction) tracks.

⚠️ Challenges we ran into

Multimodal input handling: reliably resolving image paths across containers, UI inputs, and agent services
Agent coordination: ensuring agents collaborate instead of duplicating work
Long‑running reasoning: maintaining state across extended tasks
Avoiding prompt spaghetti: designing agents as systems, not prompt blobs
Production realism: treating agents like real services with health, metrics, and failure modes

Each challenge pushed the architecture closer to real‑world DevOps standards.

🏆 Accomplishments that we're proud of

A true 9‑agent architecture, not a single LLM wrapper
Gemini Vision used for real architectural diagram analysis
Long‑running tasks with persistent reasoning state
Autonomous code generation with testing and self‑correction
Observability‑first design (metrics, health, resilience)
Clean separation of responsibilities — gold‑standard multi‑agent design
Fully containerized and reproducible system

📚 What we learned

Multi‑agent systems work best when designed like engineering teams, not prompt experiments
Observability is just as important for AI agents as for microservices
Vision + reasoning unlocks powerful architectural insights
Long‑context models enable real “ownership” of tasks over time
Structured protocols (like MCP) are essential for scalable agent systems