Transforming renewable asset development using Agentic AI

The renewable energy sector stands at a critical inflection point. The electricity demand in the USA is set to increase by 25% until 2030, meanwhile, over 90% of that demand will be covered by renewable additions. With global renewable power capacity projected to increase almost 4,600 GW between 2025 and 2030, double the deployment of the previous five years, the industry faces unprecedented challenges in planning, optimizing, and deploying clean energy assets at scale. Traditional manual processes for renewable asset planning, which can take months to complete, are becoming significant bottlenecks in a rapidly expanding market.

In this post, we dive deep into the early phase of the wind farm design process and showcase how a multi-agent AI workflow can accelerate and improve the output of this critical phase. Although we apply agentic AI to wind farm planning, a similar process could be created for solar or storage projects as well.

The challenge of scale and complexity

Modern renewable energy planning involves navigating complex interdependencies across environmental constraints, regulatory requirements, grid integration, and economic optimization. Wind farm design requires sophisticated analysis of terrain, wake effects, turbine placement, and energy yield simulation, considering setback requirements, land use compatibility, and interconnection constraints, as shown in the following figure. The initial design phase alone takes 6–18 months. Solar installations face similar complexity in site evaluation, panel layout optimization, and storage integration.

This planning phase determines site viability through wind resource measurement, land agreements, community engagement, environmental assessments, grid evaluation, preliminary turbine layout, and financial analysis. This culminates in a go/no-go decision before full permitting, engineering design, and construction. However, multiple teams with manual handovers create long iteration cycles, limiting scenario evaluations and resulting in suboptimal designs that cost millions in lost revenue over the project lifetime.

With over 2,600 GW of renewable capacity stuck in interconnection queues across the USA, speed-to-market has become the single biggest driver of energy deployment. The ability to rapidly evaluate sites and secure favorable interconnection positions provides critical competitive advantages, because faster project maturity and optimized designs improve success rates in securing capacity rights.

Figure 1: Wind farm design process

Business opportunity

Cloud and agentic AI-enabled workflows address these challenges and deliver faster time-to-market and optimized layout layouts. Therefore, we estimate the following:

• 60% cycle time reduction—from months to hours, with significant engineering cost savings
• 5x more scenario evaluations—for better risk management and comprehensive analysis
• 2+% energy output increase—through optimized layouts and improved ROI

The solution

We propose an AI-powered multi-agent system to analyze terrain, design optimal turbine layouts, and simulate wind farm performance, as shown in the following figure. Developers interact through a natural language front-end to modify constraints, re-run simulations, and compare scenarios against existing sites or industry standards.

A planning agent orchestrates the workflow across four specialized sub-agents:

• Terrain Agent: Identifies exclusion zones by analyzing bodies of water, buildings, infrastructure, and power lines using Overpass API and OpenStreetMap data. Applies turbine specifications from the National Renewable Energy Laboratory (NREL) and company-specific setbacks to generate color-coded GeoJSON boundaries for buildable land using United States Geological Survey (USGS) maps.
• Layout Agent: Creates optimal turbine layouts with spacing in elliptical patterns in the primary wind direction while avoiding exclusion zones. Wind patterns are obtained from the NREL Wind toolkit API.
• Simulation Agent: Performs wake analysis and energy calculations using PyWake library with the IEA37SimpleBastankhahGaussian wake model, outputting performance metrics, capacity factors, and AEP calculations based on NREL wind patterns and turbine power curves.
• Reporting Agent: Compiles comprehensive PDF reports with executive summaries, maps, layouts, performance metrics, financial projections, and optimization recommendations.

Figure 2: Multi-agent solution

The user can launch an entire end-to-end workflow with a request such as the following:

Run through the full workflow required to design a 30MW wind farm at location lat: 35.067482, lon: -101.395466 using IEA_Reference_3.4MW_130 turbines and output a report with all findings and simulation results.

However, in practice the engineers may be more likely to interact with one agent at the time to iterate and validate the output at each step before continuing. The following are example prompts to trigger a specific task:

1. Terrain analysis

Analyze terrain at 35.067482, -101.395466 with 5km radius. Use a setback from roads of 1.2 * turbine height. Use the turbine model "IEA_Reference_3.4MW_130

2. Layout design

Now create a turbine layout for a 60MW wind farm using IEA_Reference_3.4MW_130 turbines.

3. Energy simulation

Run a wake simulation for the layout previously generated using NREL wind conditions.

4. Report generation

Generate an executive report with charts and recommendations.

This solution demonstrates an example workflow and can be adapted to work with the existing workflows and tools of the companies. For example, the initial analysis may also be started from a pre-defined boundary polygon exported from the existing GIS tools used in the industry, rather than point coordinates. The setbacks and turbine specs may be integrated from company proprietary data. Furthermore, simulations can be performed by commercial simulation software.

Implementation

In this section, we walk through a solution that uses multiple Amazon Bedrock features and Strands Agent SDK to implement the workflow optimization use case. More code details for the deployment are available in this GitHub repository.

Architecture diagram

In this section we explore the solution architecture and each architectural component in detail. We examine its role in solving the problem and how Amazon Web Services (AWS) services enable the solution, as shown in the following figure.

Figure 3: Solution architecture

1. All agents are implemented using the open source Strands Agent SDK. This is an open source AWS toolkit that streamlines building AI agents with a loop-based architecture that enables complex, multi-step reasoning and autonomous behavior.
2. Agents use the foundational model Claude Sonnet 4 available through Amazon Bedrock.
3. Optionally, turbine specifications, or company-based constraints such as setbacks, can be retrieved from an Amazon Bedrock Knowledge Base using knowledge base ID as an input either in the agent environment or in the user prompt.
4. All agents are deployed in Amazon Bedrock AgentCore, which accelerates the deployment of agents to production with composable services that work with any framework or any model. It provides the infrastructure to host and run your agents in production, so that they can be accessed through web applications and other interfaces with built-in observability features for monitoring agent performance and behavior.
5. The tool to obtain wind conditions from NREL API is deployed as an AWS Lambda function and registered as a target to Amazon Bedrock AgentCore Gateway. This showcases how external API integrations can be deployed as reusable Model Context Protocol (MCP) tools.
6. A sample web application using Python FastAPI and a React frontend provides the end-user experience.
7. Agents and web applications are packaged as container images and pushed to Amazon Elastic Container Registry (Amazon ECR).
8. Finally, Amazon CloudWatch generative AI Observability is used to monitor invocations and track foundation model token usage.

Deep dives

In this section we dive deeper into three implementation components:

1. The orchestration approach using Agents as Tools pattern
2. The MCP Gateway implementation
3. The web application to provide the end-user-experience

Multi-agent orchestration approach: Agents as Tools
Agents as Tools is an AI pattern where specialized agents are callable functions (tools) invoked by a primary orchestrator agent. This hierarchical setup mimics a manager coordinating specialists to solve complex problems efficiently.

Key benefits include separation of concerns, modular architecture, and scalable collaboration, enabling flexible and maintainable multi-agent systems.

Structure:

• Primary orchestrator: Handles user interaction and delegates to specialized agents.
• Specialized agents: Perform domain-specific tasks independently when called.

This model fosters efficient collaboration across expert agents, as shown in the following figure.

Figure 4: Agents as Tools pattern

We implement the Agents as Tools pattern in Strands Agents SDK by decorating the agents with @tool decorator and adding these agents to the tools list of the orchestrator agent.

For example, the following snippet shows how we use the @tool decorator in the agents/terrain_agent.py to enable the Agents as Tools pattern:

@tool # This decorator transforms a Python function into a Strands tool.
def terrain_agent(region_name="us-west-2", model_id="us.anthropic.claude-sonnet-4-20250514-v1:0", query="No prompt found in input, please guide customer to create a json payload with prompt key") -> str | Agent:
  """Initialize the terrain analysis agent if called from a notebook, return agent response if called directly or as a tool."""

def wind_farm_dev_agent(region_name="us-west-2", model_id="us.anthropic.claude-sonnet-4-20250514-v1:0", disable_callback_handler=False) -> Agent:
  """Initialize the agent"""

  global agent
  logger.info(f"Initializing agent with region: {region_name}, model: {model_id}")

  tools = [
    terrain_agent, # Terrain agent as tool
    layout_agent, # Layout agent as tool
    simulation_agent, # Simulation agent as tool
    report_agent, # Report agent as tool
    generate_project_id,
    load_project_data,
    get_latest_images,
    validate_layout_quality,
    get_project_status, 
    analyze_simulation_results,
    load_layout_image
  ]

# Get AgentCore runtime ARN from SSM parameter
agentcore_runtime_arn = get_ssm_parameter('/wind-farm-assistant/agentcore-runtime-arn')

[...]

# Invoke agentcore with boto3 client
boto3_response = agentcore_client.invoke_agent_runtime(
agentRuntimeArn=agentcore_runtime_arn,
qualifier="DEFAULT",
payload=json.dumps({"prompt": prompt})
)