Build an AI Home Renovation Planner Agent using Nano Banana

Imagine uploading a photo of your outdated kitchen and instantly getting a photorealistic rendering of what it could look like after renovation, complete with budget breakdowns, timelines, and contractor recommendations. That's exactly what we're building today.

In this tutorial, you'll create a sophisticated multi-agent home renovation planner using Google's Agent Development Kit (ADK) and Gemini 2.5 Flash Image (aka Nano Banana). The system analyzes photos of your current space, understands your style preferences from inspiration images, and generates stunning visualizations of your renovated room, while keeping your budget in mind.

We're using Google ADK, an open-source framework for building production-ready AI agents. Combined with Gemini 2.5 Flash Image (the viral Nano Banana model), our agents can not only understand images but also generate photorealistic renderings of your dream space. Nano Banana brings state-of-the-art image generation and editing capabilities that maintain character consistency.

Don’t forget to share this tutorial on your social channels and tag Unwind AI (X, LinkedIn, Threads, Facebook) to support us!

What We’re Building

This application implements a multi-agent system that transforms home renovation planning from concept to visualization. It uses the Coordinator/Dispatcher pattern to route requests to specialized agents that work together seamlessly.

Features:

• Smart Image Analysis: Upload room photos and inspiration images—agents automatically detect and analyze them using Gemini's vision capabilities

• Photorealistic Rendering: Generate professional-quality images of your renovated space using Nano Banana (Gemini 2.5 Flash Image)

• Budget-Aware Planning: Tailored recommendations that respect your financial constraints

• Complete Renovation Roadmap: Timeline estimation, budget breakdown, contractor lists, and actionable checklists

• Iterative Refinement: Edit generated renderings with simple natural language ("make cabinets cream instead of white")

• Multi-Agent Orchestration: Demonstrates production-ready Coordinator/Dispatcher + Sequential Pipeline patterns

• Versioned Artifacts: Automatic version tracking for all generated renderings

How The App Works

1. User Interaction: User uploads photos or describes their renovation needs

2. Coordinator Routes Request: Root agent analyzes the request and routes to appropriate specialist

3. Visual Assessment: VisualAssessor analyzes images (current room + inspiration) and provides detailed assessment

4. Design Planning: DesignPlanner creates specific material, color, and layout recommendations

5. Project Coordination: ProjectCoordinator generates photorealistic rendering using Nano Banana, provides budget breakdown and timeline

6. Iterative Refinement: User can request edits ("make cabinets darker"), RenderingEditor refines the image

Multi-Agent Pattern:

• Coordinator/Dispatcher: Root agent routes to InfoAgent, RenderingEditor, or PlanningPipeline

• Sequential Pipeline: Planning agents run in order, each building on previous work

• State Management: ADK maintains conversation context and artifact versions

Prerequisites

Before we begin, make sure you have the following:

1. Python installed on your machine (version 3.10 or higher is recommended)

2. Google Gemini API key

3. A code editor of your choice (we recommend VS Code or PyCharm for their excellent Python support)

4. Basic familiarity with Python programming

Code Walkthrough

Setting Up the Environment

First, let's get our development environment ready:

1. Clone the GitHub repository:

git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git

🌟 Don't forget to star the opensource repo to show your support.

2. Go to the ai_home_renovation_agent folder:

cd advanced_ai_agents/multi_agent_apps/ai_home_renovation_agent

3. Install the required dependencies:

pip install -r requirements.txt

4. Grab your Google Gemini API key from Google AI Studio

Creating the Streamlit App

Let's create our app. We'll create three files: agent.py (main orchestration), tools.py (image generation tools), and __init__.py (package setup).:

File: agent.py

1. Import necessary libraries:

from google.adk.agents import LlmAgent, SequentialAgent
from google.adk.tools import google_search
from google.adk.tools.agent_tool import AgentTool
from .tools import (
    generate_renovation_rendering,
    edit_renovation_rendering,
    list_renovation_renderings,
)

2. Create Utility Tools for Cost and Timeline Estimation:

def estimate_renovation_cost(
    room_type: str,
    scope: str,
    square_footage: int,
) -> str:
    """Estimate renovation costs based on room type and scope."""
    rates = {
        "kitchen": {"cosmetic": (50, 100), "moderate": (150, 250), 
                    "full": (300, 500), "luxury": (600, 1200)},
        "bathroom": {"cosmetic": (75, 125), "moderate": (200, 350), 
                     "full": (400, 600), "luxury": (800, 1500)},
        # ... more room types
    }
    
    low, high = rates[room_type][scope]
    total_low = low * square_footage
    total_high = high * square_footage
    
    return f"💰 Estimated Cost: ${total_low:,} - ${total_high:,}"

3. Build the Visual Assessor Agent:

visual_assessor = LlmAgent(
    name="VisualAssessor",
    model="gemini-2.5-flash",
    description="Analyzes room photos and inspiration images using visual AI",
    instruction="""
You are a visual AI specialist. Analyze ANY uploaded images automatically.

DETECT:
1. CURRENT ROOM images (existing space needing renovation)
2. INSPIRATION/STYLE references (desired aesthetic)
3. Budget constraints from user messages

For CURRENT ROOM:
- Room type, size estimate, condition
- Current style, key problems
- Improvement opportunities

For INSPIRATION:
- Style name, color palette, key materials
- Notable features, design elements

Output structured summary with room details, style preferences, and budget.
""",
    tools=[AgentTool(search_agent), estimate_renovation_cost],
)

4. Create the Design Planner Agent:

design_planner = LlmAgent(
    name="DesignPlanner",
    model="gemini-2.5-flash",
    description="Creates detailed renovation design plan",
    instruction="""
Create SPECIFIC, ACTIONABLE design plan.

Design Specifications:
- Layout: [specific changes]
- Colors: [exact colors with names - "Benjamin Moore Simply White OC-117"]
- Materials: [specific products - "Shaker white cabinets"]
- Flooring: [type, color, installation]
- Lighting: [fixture types, placement]
- Storage solutions
- Key features

Match inspiration aesthetic if provided, prioritize budget-conscious choices.
""",
    tools=[calculate_timeline],
)

5. Build the Project Coordinator with Image Generation:

project_coordinator = LlmAgent(
    name="ProjectCoordinator",
    model="gemini-2.5-flash",
    description="Coordinates timeline, budget, and generates photorealistic renderings",
    instruction="""
Create final renovation plan with:
- Budget breakdown (materials, labor, permits, contingency)
- Timeline with phases
- Contractors needed
- Action checklist

Generate rendering using generate_renovation_rendering tool:

Build EXTREMELY DETAILED prompt incorporating:
- Room type and layout
- Exact colors with codes
- Specific materials and fixtures
- Lighting details
- All design elements

Example prompt structure:
"Professional interior photography of renovated [room_type].
Style: [exact style]
Colors: [Benjamin Moore Simply White OC-117 on walls]
Cabinets: [white shaker style with brushed nickel hardware]
Countertops: [Carrara marble-look quartz]
Flooring: [light oak luxury vinyl plank]
Backsplash: [white subway tile in running bond]
Camera: Wide-angle, eye-level, photorealistic, 8K quality"
""",
    tools=[generate_renovation_rendering, edit_renovation_rendering],
)

6. Create the Planning Pipeline (Sequential Agent):

planning_pipeline = SequentialAgent(
    name="PlanningPipeline",
    description="Full renovation planning: Assessment → Design → Coordination",
    sub_agents=[
        visual_assessor,
        design_planner,
        project_coordinator,
    ],
)

7. Build the Rendering Editor for Iterative Refinement:

rendering_editor = LlmAgent(
    name="RenderingEditor",
    model="gemini-2.5-flash",
    description="Edits existing renovation renderings based on feedback",
    instruction="""
Refine existing renderings based on user feedback.

Find most recent rendering filename from conversation history.
Use edit_renovation_rendering tool with:
- artifact_filename: [exact filename of latest rendering]
- prompt: [very specific edit instruction]
- asset_name: [base name without version]

Be SPECIFIC in prompts - vague instructions = poor results!
""",
    tools=[edit_renovation_rendering, list_renovation_renderings],
)

8. Create the Coordinator (Root Agent):

root_agent = LlmAgent(
    name="HomeRenovationPlanner",
    model="gemini-2.5-flash",
    description="Intelligent coordinator that routes requests to specialists",
    instruction="""
Analyze requests and route to the right specialist:

1. General questions → InfoAgent
2. Edit existing renderings → RenderingEditor
3. New renovation planning → PlanningPipeline

CRITICAL: Use transfer_to_agent - don't answer directly!
""",
    sub_agents=[
        info_agent,
        rendering_editor,
        planning_pipeline,
    ],
)

File: tools.py

9. Image Generation Tool Implementation:

from google import genai
from google.genai import types
from google.adk.tools import ToolContext

async def generate_renovation_rendering(
    tool_context: ToolContext, 
    inputs: GenerateRenovationRenderingInput
) -> str:
    """Generate photorealistic rendering using Gemini 2.5 Flash Image."""
    
    client = genai.Client()
    
    # Create versioned filename
    version = get_next_version_number(tool_context, inputs.asset_name)
    artifact_filename = create_versioned_filename(inputs.asset_name, version)
    
    # Build content for generation
    contents = [
        types.Content(
            role="user",
            parts=[types.Part.from_text(text=inputs.prompt)],
        ),
    ]
    
    # Configure for image generation
    config = types.GenerateContentConfig(
        response_modalities=["IMAGE", "TEXT"],
    )
    
    # Generate image using Nano Banana
    for chunk in client.models.generate_content_stream(
        model="gemini-2.5-flash-image",
        contents=contents,
        config=config,
    ):
        if chunk.candidates[0].content.parts[0].inline_data:
            image_part = types.Part(
                inline_data=chunk.candidates[0].content.parts[0].inline_data
            )
            
            # Save as artifact with version tracking
            await tool_context.save_artifact(
                filename=artifact_filename,
                artifact=image_part
            )
            
            return f"✅ Rendering saved as: {artifact_filename}"

File: __init__.py

10. Package Setup:

"""AI Home Renovation Planner - Multi-Agent Pattern Demo"""

from .agent import root_agent

__all__ = ["root_agent"]

Running the App

With our code in place, it's time to launch the app.

1. Start ADK Web:

cd awesome-llm-apps/advanced_ai_agents/multi_agent_apps/ai_home_renovation_agent
adk web

2. Open your browser to the URL provided (typically http://localhost:7788)

3. Select "ai_home_renovation_agent" from the app list

4. Try these example prompts:

Example 1: Upload current room photo

Example 2: Upload current room + inspiration

Example 3: Text description only

Example 4: Iterative refinement

Working Application Demo

Conclusion

You've built a production-ready AI Home Renovation Planner using Google ADK and Gemini 2.5 Flash Image (Nano Banana). This multi-agent system demonstrates real-world agentic patterns: intelligent routing, specialized agents, and sophisticated image generation capabilities.

This setup can now be expanded further:

1. 3D Visualization: Extend to generate multiple angles of the same room for comprehensive visualization

2. Before/After Comparisons: Automatically create side-by-side comparisons of current vs. renovated space

3. Contractor Matching: Integrate with contractor databases to provide personalized recommendations based on location

4. Export Capabilities: Generate PDF reports with all renderings, budgets, and timelines for sharing with contractors

5. Style Transfer from Multiple Inspirations: Blend elements from multiple inspiration images into a cohesive design

Keep experimenting with different configurations and features to build more sophisticated AI applications.

We share hands-on tutorials like this 2-3 times a week, to help you stay ahead in the world of AI. If you're serious about leveling up your AI skills and staying ahead of the curve, subscribe now and be the first to access our latest tutorials.

Don’t forget to share this tutorial on your social channels and tag Unwind AI (X, LinkedIn, Threads) to support us!