New tools

[ngoiyaeric]

Here are the official links and primary references for the agentic geospatial platforms and systems you listed.

• [Google Earth AI](https://ai.google/earth-ai/?utm_source=chatgpt.com) — Gemini-powered Earth reasoning and geospatial foundation models. ([Google AI]1)

• [Google Maps Platform Geospatial AI](https://mapsplatform.google.com/ai/?utm_source=chatgpt.com) — Google’s AI agents and geospatial developer tooling for Maps Platform. ([Google Maps Platform]2)

• [Google Maps Platform Places UI Kit](https://mapsplatform.google.com/intl/en_uk/maps-products/places-ui-kit/?utm_source=chatgpt.com) — UI toolkit and grounding layer for geospatial interfaces. ([Google Maps Platform]3)

• [NV5 GeoAgent](https://www.nv5geospatialsoftware.com/Products/GeoAgent?utm_source=chatgpt.com) — Agentic geospatial workflow system built on ENVI and MCP. ([nv5geospatialsoftware.com]4)

• [NV5 GeoAgent Launch Coverage (LIDAR Magazine)](https://lidarmag.com/2026/02/03/nv5-launches-geoagent-ushering-in-the-era-of-autonomous-geospatial-intelligence/?utm_source=chatgpt.com) — Coverage of GeoAgent autonomous geospatial workflows. ([LIDAR Magazine]5)

• [NV5 GeoAgent Coverage (DBTA)](https://www.dbta.com/Editorial/News-Flashes/NV5-GeoAgent-Offers-Autonomous-Geospatial-Intelligence-173378.aspx?utm_source=chatgpt.com) — Technical breakdown of workflow orchestration and multimodal analysis. ([Database Trends and Applications]6)

• [NV5 GeoAgent Coverage (GIM International)](https://www.gim-international.com/content/news/nv5-launches-geoagent-as-geospatial-workflows-go-autonomous?utm_source=chatgpt.com) — Discussion of autonomous geospatial intelligence workflows. ([gim-international.com]7)

Some companies you mentioned either do not yet have clearly indexed public pages for the exact products referenced, or the branding/product names appear to still be evolving in 2026 coverage. Those include:

• Esri
• CARTO
• LGND AI
• Planet Labs
• Wherobots
• Bunting Labs
• IBM

Their official sites are:

• [Esri](https://www.esri.com?utm_source=chatgpt.com)
• [CARTO](https://carto.com?utm_source=chatgpt.com)
• [LGND AI](https://www.lgnd.ai?utm_source=chatgpt.com)
• [Planet Labs](https://www.planet.com?utm_source=chatgpt.com)
• [Wherobots](https://wherobots.com?utm_source=chatgpt.com)
• [Bunting Labs](https://buntinglabs.com?utm_source=chatgpt.com)
• [IBM Research](https://research.ibm.com?utm_source=chatgpt.com)

A few additional relevant resources from the broader agentic ecosystem:

• [Google Agent Development Kit discussion](https://www.reddit.com/r/vibecoding/comments/1raamgk/google_officially_launches_the_agent_development/?utm_source=chatgpt.com) — Community discussion around Google’s open-source ADK framework. ([Reddit]8)

• [OS-ATLAS Research Paper](https://arxiv.org/abs/2410.23218?utm_source=chatgpt.com) — Foundation action models for agentic interfaces. ([arXiv]9)

• [Portal UX Agent Research Paper](https://arxiv.org/abs/2511.00843?utm_source=chatgpt.com) — Structured agentic UI rendering systems. ([arXiv]10)

• [AURORA UI Navigation Research](https://arxiv.org/abs/2404.01240?utm_source=chatgpt.com) — Autonomous interface understanding and navigation. ([arXiv]11)

[ngoiyaeric]

@coderabbitai plan how to integrate these tools to be very useful on this platform.

[coderabbitai]

Coding Plan

Summary

• Add Google Places API as a new standalone tool following the established factory pattern, keeping it separate from the existing Mapbox integration
• Route queries via updated researcher system prompt based on query type (directions/geocoding → Mapbox, place search/details → Google)
• Handle results with a dedicated section component and map handler that updates the shared MapDataContext
• Gate the tool on GOOGLE_MAPS_API_KEY presence to gracefully degrade when not configured

Design Choices

Design Choice 1: Which geospatial provider(s) to integrate first?

Options Considered:

1. Google Maps Platform APIs (Places, Geocoding) — well-documented REST APIs, codebase already supports Google as map provider
2. Google Earth Engine — powerful satellite analysis but requires separate auth flow and GEE project setup
3. Planet Labs — satellite imagery APIs requiring enterprise API keys
4. NV5 GeoAgent/Esri — enterprise platforms requiring specific licensing arrangements

Chosen Option: 1

Rationale: Google Maps Platform is the most practical first integration since the codebase already has mapProvider: 'google' support, Google has stable REST APIs, and it provides immediate value for places/geocoding alongside existing Mapbox capabilities.

Design Choice 2: Should the new tool replace or complement the existing geospatialTool?

Options Considered:

1. Create a separate Google-specific tool that runs in parallel
2. Modify the existing geospatialTool to route to different backends based on mapProvider
3. Create an abstraction layer that dispatches to provider-specific implementations

Chosen Option: 1

Rationale: Create a separate googlePlacesTool to maintain clean separation of concerns and avoid destabilizing the working Mapbox integration. The researcher prompt can route queries based on context.

💡 User Tips

Regenerate the plan with different choices with @coderabbitai <feedback>.

Implementation Steps

Phase 1: Google Places Tool Foundation

Establish the core tool infrastructure for Google Maps Platform integration, following the exact patterns used by the existing geospatial tool.

Task 1: Define Google Places Schema

Create the Zod schema that defines the parameter contract for Google Places API queries.

• Create lib/schema/google-places.tsx with a discriminated union by queryType
• Define query types: placeSearch (text search), nearbySearch (location-based), placeDetails (by place ID), autocomplete (query suggestions)
• Include common fields: query, location (lat/lng), radius, maxResults, language
• Add Google-specific fields: placeId for details queries, types filter array for category filtering

Task 2: Implement Google Places Tool

Create the tool implementation that calls Google Places API endpoints.

• Create lib/agents/tools/google-places.tsx following the factory pattern from geospatial.tsx
• Implement execute function that routes to appropriate Google API endpoints based on queryType:
  • Text Search: https://places.googleapis.com/v1/places:searchText
  • Nearby Search: https://places.googleapis.com/v1/places:searchNearby
  • Place Details: https://places.googleapis.com/v1/places/{placeId}
• Use GOOGLE_MAPS_API_KEY environment variable for authentication
• Return structured output with type: 'GOOGLE_PLACES_RESULT' discriminator
• Include places array with normalized fields: name, address, location, rating, types, placeId
• Stream UI feedback via uiStream.append() during API calls

Task 3: Register Tool in Tool Index

Add the new tool to the registry so it's available to the researcher agent.

• Update lib/agents/tools/index.tsx to import googlePlacesTool
• Add conditional registration based on GOOGLE_MAPS_API_KEY presence (following videoSearch pattern)
• Extend ToolProps interface if additional props are needed

🤖 Prompt for AI agents

Implement the core Google Places tool infrastructure, following the exact
factory pattern used by the existing `geospatial.tsx` tool.

**1. Create `lib/schema/google-places.tsx`:**
- Define a Zod schema with a discriminated union on `queryType`
- Supported query types: `placeSearch`, `nearbySearch`, `placeDetails`,
`autocomplete`
- Common fields: `query`, `location` (lat/lng), `radius`, `maxResults`,
`language`
- Google-specific fields: `placeId` (for details queries), `types` (filter array
for category filtering)

**2. Create `lib/agents/tools/google-places.tsx`:**
- Follow the factory pattern from `geospatial.tsx`
- Implement an `execute` function that routes to the correct Google Places API
endpoint based on `queryType`:
  - Text Search → `https://places.googleapis.com/v1/places:searchText`
  - Nearby Search → `https://places.googleapis.com/v1/places:searchNearby`
  - Place Details → `https://places.googleapis.com/v1/places/{placeId}`
- Authenticate using the `GOOGLE_MAPS_API_KEY` environment variable
- Return structured output with `type: 'GOOGLE_PLACES_RESULT'` as the
discriminator
- The `places` array in the output should include normalized fields: `name`,
`address`, `location`, `rating`, `types`, `placeId`
- Stream UI feedback via `uiStream.append()` during API calls

**3. Update `lib/agents/tools/index.tsx`:**
- Import `googlePlacesTool`
- Conditionally register it based on the presence of `GOOGLE_MAPS_API_KEY`
(mirror the `videoSearch` conditional registration pattern)
- Extend the `ToolProps` interface if additional props are required

Phase 2: Agent Integration

Update the researcher agent to understand when and how to use the new Google Places tool.

Task 1: Update Researcher System Prompt

Modify the tool routing directives to include the new tool.

• Update lib/agents/researcher.tsx getDefaultSystemPrompt() function
• Add directive for googlePlacesTool: use for business/POI searches, place details, and location autocomplete when Google-specific features are needed (reviews, photos, opening hours)
• Clarify routing: use geospatialQueryTool for directions/distance/geocoding; use googlePlacesTool for rich place data
• Consider adding mapProvider context to the prompt so LLM can prefer Google tools when Google Maps is selected

Task 2: Add Tool Types

Define TypeScript types for the new tool's input and output shapes.

• Update lib/types/index.ts with GooglePlacesResult and GooglePlace interfaces
• Define the output shape matching what the tool returns
• Export types for use in handler components

🤖 Prompt for AI agents

Integrate the new Google Places tool into the researcher agent by updating its
system prompt and adding the necessary TypeScript types.

**1. Update `lib/agents/researcher.tsx` — `getDefaultSystemPrompt()` function:**
- Add a routing directive for `googlePlacesTool`: use it for business/POI
searches, place details, and location autocomplete when Google-specific features
are needed (reviews, photos, opening hours)
- Add a clarification on routing: `geospatialQueryTool` for
directions/distance/geocoding; `googlePlacesTool` for rich place data
- Optionally inject `mapProvider` context into the prompt so the LLM prefers
Google tools when Google Maps is the active provider

**2. Update `lib/types/index.ts`:**
- Add `GooglePlacesResult` interface matching the tool's return shape (including
`type: 'GOOGLE_PLACES_RESULT'` and a `places` array)
- Add `GooglePlace` interface with fields: `name`, `address`, `location`,
`rating`, `types`, `placeId`
- Export both interfaces for use in handler and section components

Phase 3: Result Display Integration

Handle the new tool's output in the UI layer to render place results appropriately.

Task 1: Create Places Result Handler

Build the component that processes Google Places tool output.

• Create components/google-places-handler.tsx as a side-effect component (like MapQueryHandler)
• Accept toolOutput prop typed to the Google Places result shape
• Use useMapData() to update map context: set markers array for multiple places, targetPosition for single result
• Handle error states gracefully

Task 2: Create Places Result Section

Build the UI component that displays place search results.

• Create components/google-places-section.tsx following SearchSection pattern
• Display places in a card layout with name, address, rating, types
• Include links to Google Maps for each place
• Support streaming via useStreamableValue if results come progressively

Task 3: Wire Up Result Handling in Actions

Connect the tool output to the display components.

• Update app/actions.tsx getUIStateFromAIState function
• Add if block before the switch (name) to intercept toolOutput.type === 'GOOGLE_PLACES_RESULT'
• Return composite component: <GooglePlacesSection> for display + <GooglePlacesHandler> for map updates
• Set isCollapsed: false to match geospatial tool behavior

Task 4: Update Tool Badge

Add icon mapping for the new tool label.

• Update components/tool-badge.tsx to include icon for googlePlacesTool
• Use appropriate icon (e.g., MapPin or Building from lucide-react)

🤖 Prompt for AI agents

Build the UI layer to display Google Places tool results and update the map,
following existing component patterns.

**1. Create `components/google-places-handler.tsx`:**
- Model it as a side-effect component, similar to `MapQueryHandler`
- Accept a `toolOutput` prop typed to `GooglePlacesResult`
- Use `useMapData()` to update the map context: set the `markers` array for
multiple places, and `targetPosition` for a single result
- Handle error states gracefully

**2. Create `components/google-places-section.tsx`:**
- Follow the `SearchSection` pattern
- Display places in a card layout showing: name, address, rating, and types
- Include a link to Google Maps for each place
- Support streaming via `useStreamableValue` if results arrive progressively

**3. Update `app/actions.tsx` — `getUIStateFromAIState` function:**
- Add an `if` block before the `switch (name)` statement to intercept
`toolOutput.type === 'GOOGLE_PLACES_RESULT'`
- Return a composite component: `<GooglePlacesSection>` for display and
`<GooglePlacesHandler>` for map updates
- Set `isCollapsed: false` to match the geospatial tool behavior

**4. Update `components/tool-badge.tsx`:**
- Add an icon mapping entry for `googlePlacesTool`
- Use an appropriate icon such as `MapPin` or `Building` from `lucide-react`

Phase 4: Environment and Configuration

Ensure proper configuration for the new integration.

Task 1: Document Environment Variables

Add configuration documentation and validation.

• Add GOOGLE_MAPS_API_KEY to environment variable documentation
• Update any env validation utilities to include the new key
• Ensure the key has Places API (New) enabled in Google Cloud Console

Task 2: Update Settings Store (Optional Enhancement)

Consider surfacing tool availability in settings.

• Optionally extend lib/store/settings.ts to track which geospatial providers are available
• This enables future UI to show users which tools are configured

🤖 Prompt for AI agents

Finalize environment configuration and optional settings store updates to
support the new Google Places integration.

**1. Document `GOOGLE_MAPS_API_KEY`:**
- Add `GOOGLE_MAPS_API_KEY` to all environment variable documentation files
(e.g., `.env.example`, `README`)
- Update any env validation utilities to include and validate the new key
- Add a note that the key must have the Places API (New) enabled in Google Cloud
Console

**2. (Optional) Update `lib/store/settings.ts`:**
- Optionally extend the settings store to track which geospatial providers are
currently available/configured
- This lays groundwork for future UI that surfaces configured tool availability
to users

Research

The codebase uses a pipeline of specialized agents orchestrated by app/actions.tsx. Tools follow a factory pattern defined in lib/agents/tools/, with Zod schemas in lib/schema/, and registration in getTools(). The existing geospatialTool connects to Mapbox via Composio MCP. There's already a mapProvider setting supporting both 'mapbox' and 'google', and a GoogleMapComponent exists, making Google Maps Platform the natural next integration target.

---

🚀 Next Steps

🤖 All AI agent prompts combined

Task: 1

Implement the core Google Places tool infrastructure, following the exact
factory pattern used by the existing `geospatial.tsx` tool.

**1. Create `lib/schema/google-places.tsx`:**
- Define a Zod schema with a discriminated union on `queryType`
- Supported query types: `placeSearch`, `nearbySearch`, `placeDetails`,
`autocomplete`
- Common fields: `query`, `location` (lat/lng), `radius`, `maxResults`,
`language`
- Google-specific fields: `placeId` (for details queries), `types` (filter array
for category filtering)

**2. Create `lib/agents/tools/google-places.tsx`:**
- Follow the factory pattern from `geospatial.tsx`
- Implement an `execute` function that routes to the correct Google Places API
endpoint based on `queryType`:
  - Text Search → `https://places.googleapis.com/v1/places:searchText`
  - Nearby Search → `https://places.googleapis.com/v1/places:searchNearby`
  - Place Details → `https://places.googleapis.com/v1/places/{placeId}`
- Authenticate using the `GOOGLE_MAPS_API_KEY` environment variable
- Return structured output with `type: 'GOOGLE_PLACES_RESULT'` as the
discriminator
- The `places` array in the output should include normalized fields: `name`,
`address`, `location`, `rating`, `types`, `placeId`
- Stream UI feedback via `uiStream.append()` during API calls

**3. Update `lib/agents/tools/index.tsx`:**
- Import `googlePlacesTool`
- Conditionally register it based on the presence of `GOOGLE_MAPS_API_KEY`
(mirror the `videoSearch` conditional registration pattern)
- Extend the `ToolProps` interface if additional props are required
===============================================================================

Task: 2

Integrate the new Google Places tool into the researcher agent by updating its
system prompt and adding the necessary TypeScript types.

**1. Update `lib/agents/researcher.tsx` — `getDefaultSystemPrompt()` function:**
- Add a routing directive for `googlePlacesTool`: use it for business/POI
searches, place details, and location autocomplete when Google-specific features
are needed (reviews, photos, opening hours)
- Add a clarification on routing: `geospatialQueryTool` for
directions/distance/geocoding; `googlePlacesTool` for rich place data
- Optionally inject `mapProvider` context into the prompt so the LLM prefers
Google tools when Google Maps is the active provider

**2. Update `lib/types/index.ts`:**
- Add `GooglePlacesResult` interface matching the tool's return shape (including
`type: 'GOOGLE_PLACES_RESULT'` and a `places` array)
- Add `GooglePlace` interface with fields: `name`, `address`, `location`,
`rating`, `types`, `placeId`
- Export both interfaces for use in handler and section components
===============================================================================

Task: 3

Build the UI layer to display Google Places tool results and update the map,
following existing component patterns.

**1. Create `components/google-places-handler.tsx`:**
- Model it as a side-effect component, similar to `MapQueryHandler`
- Accept a `toolOutput` prop typed to `GooglePlacesResult`
- Use `useMapData()` to update the map context: set the `markers` array for
multiple places, and `targetPosition` for a single result
- Handle error states gracefully

**2. Create `components/google-places-section.tsx`:**
- Follow the `SearchSection` pattern
- Display places in a card layout showing: name, address, rating, and types
- Include a link to Google Maps for each place
- Support streaming via `useStreamableValue` if results arrive progressively

**3. Update `app/actions.tsx` — `getUIStateFromAIState` function:**
- Add an `if` block before the `switch (name)` statement to intercept
`toolOutput.type === 'GOOGLE_PLACES_RESULT'`
- Return a composite component: `<GooglePlacesSection>` for display and
`<GooglePlacesHandler>` for map updates
- Set `isCollapsed: false` to match the geospatial tool behavior

**4. Update `components/tool-badge.tsx`:**
- Add an icon mapping entry for `googlePlacesTool`
- Use an appropriate icon such as `MapPin` or `Building` from `lucide-react`
===============================================================================

Task: 4

Finalize environment configuration and optional settings store updates to
support the new Google Places integration.

**1. Document `GOOGLE_MAPS_API_KEY`:**
- Add `GOOGLE_MAPS_API_KEY` to all environment variable documentation files
(e.g., `.env.example`, `README`)
- Update any env validation utilities to include and validate the new key
- Add a note that the key must have the Places API (New) enabled in Google Cloud
Console

**2. (Optional) Update `lib/store/settings.ts`:**
- Optionally extend the settings store to track which geospatial providers are
currently available/configured
- This lays groundwork for future UI that surfaces configured tool availability
to users

💡 Iterate on the plan with: `@coderabbitai` <feedback>

Example Feedback
- `@coderabbitai` You can skip phase 3. Add a simple unit test case for phase 2.
- `@coderabbitai` For design choice 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!