GeoAnalysis AI: UK Energy Prospect Finder

Autonomous AWS Bedrock agent that plans energy infrastructure by reasoning over geospatial, seismic & environmental data—no GIS expertise needed

Comment

GeoAnalysis AI: UK Energy Prospect Finder

An autonomous AI agent for energy infrastructure planning, built with AWS Bedrock AgentCore

🌟 Inspiration

As a Research Fellow, I observed that the oil and gas sector—an industry critical to global energy—has been slow to adopt AI-driven decision support. Most AI applications remain siloed or require manual data pipelines, limiting real-world impact.

I set out to build something different: an autonomous AI agent that could independently reason over public energy and environmental data to answer complex planning questions—no data scientists or GIS experts required. By combining AWS Bedrock AgentCore with domain-specific tools, I aimed to demonstrate how agentic AI can unlock value in data-rich but AI-underserved industries.

🚀 What it does

GeoAnalysis AI is not just a dashboard—it’s an autonomous agent that interprets natural language requests about energy site feasibility and orchestrates a full analytical workflow using geospatial, risk, and decision tools.

When asked a question like “Where should we build a low-risk offshore wind farm near Aberdeen?”, the agent:

  • Understands the intent,
  • Plans a sequence of analytical steps,
  • Calls specialized tools (e.g., seismic risk, infrastructure proximity, MCDA),
  • Synthesizes results,
  • And returns a complete, actionable report with visualizations—all without human intervention.

It leverages public UK Continental Shelf (UKCS) data and real-time Copernicus Marine Service APIs, but the data is secondary—the agent’s reasoning and orchestration are the core innovation.

🧠 Agent Capabilities

The agent is equipped with a suite of registered tools, enabling it to autonomously execute complex energy planning tasks:

Autonomous Block Evaluation

  • The agent includes a run_mcda_analysis tool that evaluates candidate sites by applying user-defined weights across environmental, technical, economic, and safety criteria—enabling transparent, multi-factor ranking without manual spreadsheet modeling.
  • Returns quantifiable rankings with justifications traceable to input criteria.

Infrastructure Conflict Detection

  • Analyzes spatial relationships between wells, pipelines, seismic zones, and protected areas by calling proximity tools within user-defined radii.
  • Flags high-risk overlaps for mitigation.

Low-Impact Site Generation

  • Plans optimal exploration or wind farm locations by chaining environmental constraint tools with operational feasibility checks.
  • Supports scenario-based strategy comparisons.

Global Renewable Siting

  • Extends analysis beyond the UK by adapting constraint systems for international offshore wind planning.
  • Applies region-specific environmental weighting via tool configuration.

End-to-End Risk Profiling

  • Assesses composite risk by sequentially invoking seismic, ecological, and infrastructure tools.
  • Generates location-specific mitigation recommendations.

Self-Contained Reporting

  • Synthesizes all tool outputs into a natural language summary with embedded interactive maps.
  • Delivers strategic insights through a conversational interface.

🤖 End-to-End Agentic Workflow Example

To demonstrate autonomous reasoning and tool orchestration, consider this user query:
“Evaluate risks associated with building a wind farm in Aberdeen.”

The GeoAnalysis AI agent executes the following reasoning loop without human intervention:

  1. Plan: Parse the intent and decompose the task into sub-goals (geolocation, risk layers, synthesis).
  2. Act: Sequentially invoke registered tools via AWS Bedrock AgentCore:
    • geocode_location("Aberdeen") → returns coordinates
    • get_location_bounds(...) → defines analysis region
    • assess_seismic_risk_at_location(...) → fetches UK seismic hazard data
    • assess_infrastructure_proximity(...) → checks pipelines, wells, and protected zones
    • calculate_overall_risk_score(...) → applies MCDA weights to generate a composite risk score
    • create_risk_assessment_map(...) → renders an interactive Folium map with layered risk visualizations
  3. Observe & Synthesize: Aggregate tool outputs, validate spatial and logical consistency, and generate a natural language summary enriched with data-driven insights.
  4. Respond: Return a structured risk assessment report—including an embedded interactive map, score breakdown by criterion (seismic, environmental, infrastructural), and actionable mitigation recommendations—in a single conversational turn.

This multi-step, tool-augmented workflow—orchestrated entirely by the agent using AWS Bedrock AgentCore—satisfies the hackathon’s core requirements for reasoning-based decision-making, integration with external APIs and geospatial tools, and autonomous execution of complex, real-world tasks.

Try These Example Queries

To explore the agent’s capabilities, ask any of the following in the Gradio interface:

  • “Assess the risk for building an offshore wind farm near Aberdeen”
  • “What about Peterhead?”
  • “Plan low-impact exploration sites in the North Sea with 10 km grid cells”
  • “Now double the economic weight and re-rank”
  • “Find all wells within 10 km of existing pipelines”
  • “Show seismic events in offshore fields”
  • “Explore wind farm sites in Africa with high economic potential and low environmental impact (20 km grid)”
  • “What data sources do you have access to?”

💡 The agent maintains conversational context—so follow-up questions like “Do it again with safety prioritized” work seamlessly.

🛠️ How we built it

Agent Orchestration Layer

  • Built on AWS Bedrock AgentCore, using Runtime primitives to manage tool registration, execution, and response synthesis.
  • Implements a full reasoning loop: intent parsing → tool planning → sequential execution → validation → natural language response generation.
  • All tools are exposed as structured, Pydantic-validated functions to ensure reliable, type-safe invocation by the LLM.

Registered Agent Tools

The agent uses eight core tools, all registered with AWS Bedrock AgentCore as structured, Pydantic-validated functions:

  1. get_available_data_sources() – Lists all public datasets available for analysis (e.g., UKCS licensing, seismic catalogs, marine layers).
  2. geocode_location(query: str) – Converts a location name (e.g., “Aberdeen”) into precise latitude/longitude coordinates.
  3. get_location_bounds(coords: tuple) – Defines a geographic analysis region (bounding box or buffer) around a point.
  4. assess_seismic_risk_at_location(bounds: dict) – Evaluates seismic hazard by counting historical earthquake events within the region.
  5. assess_infrastructure_proximity(bounds: dict) – Identifies nearby wells, pipelines, and protected zones to flag conflict risks.
  6. calculate_overall_risk_score(seismic, proximity, environmental) – Synthesizes individual risk components into a composite score with mitigation recommendations.
  7. run_mcda_analysis(criteria_weights: dict) – Performs multi-criteria decision analysis to rank candidate sites using user-defined weights across environmental, technical, economic, and safety factors.
  8. create_risk_assessment_map(results: dict) – Generates an interactive Folium map visualizing risk layers, infrastructure, and optimal sites.

Note: Higher-level capabilities like low-impact exploration planning and global wind farm siting emerge from the agent dynamically chaining these primitives—demonstrating true compositional autonomy without hard-coded workflows.

These tools are invoked autonomously by the agent during task execution—no human-in-the-loop coordination is required. Each abstracts complex geospatial logic behind a clean, agent-compatible interface.

Geospatial Tool Implementation

  • Agent tools are implemented using GeoPandas, Shapely, and SciPy for spatial operations, Pandas, NumPy, and xarray for data processing, and Folium for interactive mapping.
  • Real-time oceanographic data is fetched via the Copernicus Marine Service API; UK energy and licensing data comes from public government sources stored in Amazon S3.

Frontend & Deployment

  • Hosted on Hugging Face Spaces using Gradio to provide a conversational user interface.
  • A custom post-generation Docker build process ensures GDAL and GeoPandas compatibility in deployment—critical for geospatial functionality (see Challenges).

🚧 Challenges we ran into

Pydantic AI Integration Challenge

The primary technical hurdle involved Pydantic AI's current limitation regarding direct tool result returns. The framework doesn't officially support returning tool results without summarization, which posed a significant problem since our AI agent needed to return HTML results for Gradio display. Summarizing HTML would corrupt the output and consume unnecessary tokens.

Solution: We implemented a workaround based on community contributions (GitHub PR #142), allowing direct result passage without summarization.

Deployment Infrastructure Challenge

Deploying the application required GeoPandas, which depends on GDAL-related installations. The Bedrock AgentCore starter toolkit didn't provide direct Dockerfile modification capabilities, creating deployment complications.

Solution: We developed a post-generation Dockerfile modification process, ensuring the application receives the customized Docker configuration needed for GeoPandas support. This highlighted the need for more flexible containerization options in AI agent frameworks.

🏆 Accomplishments that we're proud of

Successfully delivering a fully autonomous AI agent that bridges advanced geospatial analysis with natural language interaction—despite immature tooling ecosystems—is our primary achievement.

This project proves that Bedrock AgentCore can power real-world, multi-step decision agents in regulated, data-intensive industries.

This project embodies the spirit of the hackathon: an agent of change—turning complex energy planning into an autonomous, conversational experience.

📚 What we learned

Building agentic systems today requires deep integration workarounds, but the payoff is immense: an interface where experts can ask complex questions and get expert-grade answers—without writing code or running GIS software.

We also learned that tool design is critical: clean, atomic, and well-typed tools make agents more reliable and debuggable.

🔮 What's next for GeoAnalysis AI

Agent Intelligence Upgrades

  • Add predictive risk models as new agent tools (e.g., predict_sea_level_rise_impact)
  • Enable multi-agent collaboration (e.g., one for renewables, one for oil/gas)

Tool Ecosystem Expansion

  • Integrate more public APIs (e.g., NOAA, EMODnet) as agent-callable tools
  • Add time-series analysis tools for lifecycle planning

Deployment & Scale

  • Package as an AWS Marketplace solution with Bedrock AgentCore
  • Support role-based agent personas (e.g., “Environmental Officer”, “Drilling Engineer”)

Built with ❤️ for the future of energy exploration and environmental sustainability

Built With

  • amazon-web-services
  • bedrock-agentcore
  • bedrock-agentcore-starter-toolkit
  • copernicusmarine
  • folium
  • geopandas
  • gradio
  • pydantic-ai
  • xarray
Share this project:

Updates