AWS Infrastruct

From prompt to production. The AI agent that understands your vision in plain English and automatically builds your complete AWS infrastructure.

Comment

Inspiration

The cloud is powerful, but deploying infrastructure is notoriously complex, slow, and requires deep expertise in tools like CloudFormation or Terraform. This complexity creates a significant barrier, slowing down developers and making the cloud less accessible for students, startups, and managers. We asked ourselves: What if you could bypass the complexity entirely? What if you could build your cloud infrastructure just by describing what you need in plain English? Our inspiration was to democratize cloud deployment, transforming it from a specialized, code-heavy task into a simple, conversational experience.

What it does

Infrastruct is an AI agent that acts as an autonomous cloud solutions architect, turning natural language prompts into fully deployed AWS infrastructure. A user simply describes their goal, like "I need a scalable web server for my new application," and clicks send. From there, Infrastruct handles the entire lifecycle:

  • Plans an optimal architecture by reasoning about the user's request using Amazon Bedrock.

  • Provides an Architecture Diagram for the plan and the estimated monthly cost to run the plan.

  • Generates secure, pre-validated Infrastructure as Code (CloudFormation templates) based on the plan.

  • Autonomously deploys the infrastructure into the user's AWS account.

  • Provides real-time status updates to the user through a simple GUI / CLI interface.

It's a true "prompt-to-production" experience that makes cloud deployment as easy as having a conversation.

Key Features

  1. AI-Powered Architecture Planning Uses Claude 3 Sonnet via AWS Bedrock to analyze requirements Generates detailed technical specifications and architecture plans Provides AWS best practices and solution patterns Considers performance, security, and cost optimization
  2. Visual Architecture Diagramming Creates multiple diagram formats (ASCII, Mermaid, PlantUML) Shows component relationships and data flow Interactive web-based diagram rendering Exports diagrams for documentation
  3. Intelligent Cost Estimation Provides detailed monthly pricing breakdowns Creates formatted cost tables by service Considers usage patterns and scaling requirements Helps with budget planning and optimization
  4. Infrastructure as Code Generation Generates CloudFormation YAML templates Includes proper resource tagging and naming Environment-specific configurations (dev/staging/prod) Template validation and syntax checking
  5. Automated AWS Deployment Nova-Act Integration: Browser automation for AWS Console Direct API Deployment: CloudFormation stack management One-click deployment with status monitoring
  6. Comprehensive Session Management in the GUI SQLite database for chat history storage Session-based workflow state tracking File cleanup and S3 template management Search and organize previous projects

How we built it

Project Genesis & Vision

We set out to build an AI-powered AWS infrastructure assistant that could take natural language descriptions and turn them into production-ready cloud deployments. The vision was ambitious: create a system that acts like a personal AWS Solutions Architect, handling everything from planning to deployment. We utilized the Nova Act SDK for browser based deployment via AWS console instead of backend APIs to ensure that the user can see what actions the Infrastruct agent is performing in their AWS account (observability).

Architecture Diagram

Infrastruct Architecture Diagram

Core Architecture Decisions

AI Agent Framework Selection

We chose Strands Framework for multi-agent orchestration

from strands import Agent
from strands.models import BedrockModel

This gave us: -Tool chaining capabilities -AWS Bedrock integration -Structured agent workflows

Why Strands?

  • Native AWS Bedrock support -Tool-based agent architecture
  • Easy to extend with custom tools
  • Handles complex multi-step workflows

Modular Tool Architecture

We built specialized tools for each workflow step:

 tools/

├── planner_agent_tool.py      # Architecture planning

├── estimator_agent_tool.py    # Cost estimation  

├── templating_agent_tool.py   # CloudFormation generation

├── deployer_agent_tool.py     # AWS deployment

├── diagramming_agent_tool.py  # Visual diagrams

└── enhanced_*.py              # Advanced versions

Each tool is self-contained and can be used independently or chained together.

Development Phases

Phase 1: Core AI Agent System Started with basic agent setup

self.aws_infrastruct_agent = Agent(
    model=BedrockModel(
        model_id="anthropic.claude-3-sonnet-20240229-v1:0",
        region_name="us-east-1"
    ),
    system_prompt=SYSTEM_PROMPT,
    tools=[
        plan_architecture,
        estimate_price, 
        gen_template,
        deploy_infrastructure
    ]
)

Phase 2: GUI Development Built comprehensive Tkinter interface

class InfrastructGUI:
    def __init__(self, root):
        # Multi-tab interface
        self.notebook = ttk.Notebook(content_frame)

        # Created specialized tabs:
        self.create_chat_tab()      # Main interaction
        self.create_plan_tab()      # Architecture display
        self.create_diagram_tab()   # Visual diagrams
        self.create_template_tab()  # YAML templates
        self.create_deployment_tab() # AWS deployment

Design Philosophy: Workflow-driven UI (follows natural progression) Real-time feedback and status updates Persistent session management Multiple visualization formats

Phase 3: Browser Automation Integration Nova-Act SDK integration for AWS Console automation

This enabled:

  • Direct AWS Console interaction
  • Real-time deployment monitoring

Phase 4: Enhanced Diagramming System Multiple diagram format support

class EnhancedDiagramGenerator:
    def generate_diagrams(self, plan, title):
        return {
            'ascii': self.create_ascii_diagram(plan),
            'mermaid': self.create_mermaid_diagram(plan),
            'plantuml': self.create_plantuml_diagram(plan)
        }

We wanted to ensure diagramming was accessible in multiple formats:

  • ASCII art for immediate display
  • Mermaid.js for web rendering
  • PlantUML for professional diagrams
  • Interactive webview integration

Phase 5: Session Management & Persistence SQLite-based chat history system

class ChatHistoryManager:
    def __init__(self):
        self.db_path = "database/chat_sessions.db"
        self.init_database()

    def create_session(self, title, interface_type):
        # Store complete workflow state
        # Track files and resources
        # Enable session restoration

Features Added:

  • Complete conversation history
  • Workflow state persistence
  • File association tracking

Advanced Features Development

Template Cleanup Management

Comprehensive file lifecycle management: When an architecture plan is deleted by the user its template in local and cloud storage are deleted.

class TemplateCleanupManager:
    def cleanup_session_files(self, session_title, session_id):
        # Clean local CloudFormation templates
        # Remove S3 uploaded files

Enhanced Templating System

Advanced CloudFormation generation : Infrastructure as Code templates are generated for plug and play into cloudformation.

class EnhancedTemplatingTool:
    def generate_template(self, plan, envid):
        # Proper resource tagging
        # Environment-specific configurations
        # Best practices implementation
        # Validation and syntax checking

Multi-Deployment Strategy

Multiple deployment approaches: If browser automation via Nova Act fails, the agent will provide a manual deployment guide.

deployment_methods = {
    'nova_act': deploy_to_aws_direct,      # Browser automation
    'manual': generate_instructions        # Step-by-step guide
}

Development Tools & Technologies

Core Stack:

  • Python 3.13.6: Main development language
  • Tkinter: GUI framework (cross-platform)
  • SQLite: Session and history storage
  • AWS Bedrock: AI model hosting
  • Strands Framework: Agent orchestration

AI & Automation:

  • Claude 3 Sonnet: Primary AI model
  • Nova-Act SDK: browser integration,automation and infrastruct agent observability

Visualization:

  • ASCII Art: Immediate diagram display
  • Mermaid.js: Interactive web diagrams
  • PlantUML: Professional diagram export
  • Tkinter Canvas: Custom drawing capabilities

AWS Integration:

  • Boto3: AWS API interactions -CloudFormation: Infrastructure templates
  • S3: Template storage and management
  • IAM: Permissions and security

Challenges we ran into

The Nova Act SDK gave us some issues as it could not be called directly requiring us to fall back to visual studio code extension. Several attempts where performed to ensure full integration with little success.

Accomplishments that we're proud of

We successfully built a comprehensive AI-powered infrastructure assistant that:

  • Reduces deployment time from hours to minutes
  • Eliminates manual errors through automation
  • Provides learning opportunities through detailed explanations
  • Scales from simple to complex infrastructure needs
  • Integrates with existing workflows seamlessly

The project demonstrates how AI agents, browser automation, and thoughtful UX design can transform complex technical workflows into accessible, automated experiences.

What we learned

The strands agents framework makes it easy to build autonomous AI applications. It integrates easily into the AWS ecosystem making cloud development a breeze. When combined with Bedrock Agent core and other services, your imagination is the only limitation.

What's next for AWS Infrastruct

The Nova Act Model functionality in the Infrastruct project needs to be refined for it to be production ready. The Nova Act SDK is still in preview. When production ready Infrastruct users will be able to fully experience automated deployment and see the the agent's actions (observability).

Built With

Share this project:

Updates