GeoAgent

GeoAgent Mission Intelligence UI
GeoAgent Multi-Agent Architecture
Nice Looking GeoAgent Architecture

Inspiration

The inspiration for GeoAgent came partly from my own recent experience arranging an external courier for international shipping. What sounded like a straightforward logistics task became surprisingly time-consuming, involving repeated communication, coordinating collection and delivery details, providing information across different parties, and keeping track of the operation manually.

That experience made me think about how much human coordination is still required in real-world logistics, even when the underlying problem is fundamentally about resources, locations, constraints, and planning.

At the same time, I had been interested in combining multi-agent AI systems with geospatial intelligence. Logistics felt like a natural application: different specialized agents could reason about organizational resources, geographic conditions, routes, and operational constraints, then collaborate to turn a high-level objective into an executable plan.

GeoAgent grew from those two ideas: reducing the coordination overhead I had experienced personally, while exploring how autonomous multi-agent systems could use geospatial data to plan and coordinate real-world operations.

What it does

GeoAgent is an autonomous multi-agent system for planning and coordinating real-world operations using organizational data and live geospatial intelligence.

Users create a workspace, connect SQL databases containing their organizational data, and describe a mission objective in natural language. GeoAgent can inspect complex database schemas and reason across operational information such as jobs, vehicles, drivers, depots, resources, schedules, and constraints. This allows organizations to use their existing structured data without requiring users to understand the underlying database schema or manually extract and restructure information for each mission.

Users also do not need to be prompt engineering experts. If a mission objective is ambiguous or missing information required for planning, GeoAgent can ask targeted clarifying questions before proceeding. The user's answers become part of the mission context, allowing the system to resolve uncertainty instead of making unsupported assumptions or requiring a carefully engineered initial prompt.

Once the objective is sufficiently defined, GeoAgent coordinates specialized AI agents to understand organizational resources and constraints, gather relevant live geospatial intelligence, optimize assignments, calculate operational metrics, and validate whether the resulting plan is feasible. If validation determines that a plan is infeasible, GeoAgent can replan using the identified constraints rather than simply returning an unusable result.

As a mission runs, users can follow live agent activity and see how the specialized agents collaborate and how the operation progresses. Once execution is complete, GeoAgent preserves that activity as mission history so users can inspect what the agents did and how the final result was produced.

The completed mission provides a structured operational plan containing assignments, routes, schedules and mission metrics. Routes and operational locations are visualized on an interactive map, connecting the generated plan directly to its real-world geographic context.

GeoAgent also includes a Conversational Agent that provides an intelligent interface across the entire workspace. Users can ask natural-language questions across multiple missions, connected SQL data sources, generated plans, and agent activity, both while missions are running and after they have completed. It can retrieve, combine, compare, and explain operational information without requiring users to manually search database tables, individual missions, or agent histories.

Rather than requiring users to understand database schemas, coordinate multiple planning tools, inspect separate information sources, or become prompt engineering experts, GeoAgent allows them to provide a high-level operational objective and autonomously turns it into a structured, optimized, validated, geographically grounded, and inspectable operational plan.

How I built it

I built GeoAgent as a full-stack multi-agent system with a React, TypeScript, Vite, and Tailwind frontend connected to a Python FastAPI backend.

The agent architecture is built with Google Agent Development Kit (ADK) and Gemini. A Mission Manager orchestrates a team of specialized agents: an Organizational Data Agent for understanding resources and operational constraints, a Geospatial Intelligence Agent for gathering route and location intelligence, and a Planning & Validation Agent for optimizing assignments, calculating metrics, validating feasibility, and triggering bounded replanning when necessary.

Rather than relying only on free-form agent responses, I built structured tools and persistent mission state around the agents. This allows GeoAgent to load mission context, save checkpoints, request clarification when necessary, validate plans, publish final results, and preserve agent activity for inspection.

For geospatial intelligence, I integrated Google Maps Platform, including routing, geocoding, places, elevation and map visualization capabilities. This allows the agents to combine organizational data with real-world geographic context when constructing operational plans.

I also built a separate Conversational Agent/Chatbot as the workspace-wide intelligence layer. It can query across missions, plans, connected data sources, and persisted agent activity, allowing users to ask questions about both live and historical operations.

For production, GeoAgent is deployed on Google Cloud Run, with Firestore providing persistent workspace, mission, plan, and agent-event storage. Cloud Storage handles uploaded organizational datasets, Artifact Registry stores deployment artifacts, and Google Cloud logging and observability provide visibility into the production system.

Together, these components create an end-to-end architecture where Gemini and ADK handle agentic reasoning and collaboration, Google Maps provides geospatial intelligence, and Google Cloud provides the infrastructure needed to run and persist the complete system.

Challenges I ran into

One of the biggest challenges was time. I only found out about the hackathon around a week before the submission deadline, so I had to be deliberate about where I spent that limited time.

Rather than immediately writing code, I spent a significant part of the week on system design, multi-agent architecture, and detailed technical specifications. I then used those specifications to guide coding agents through rapid implementation and testing. This allowed me to spend more of my time making architectural decisions, defining agent behaviour, designing integrations, and evaluating whether the complete system worked as intended.

Keeping coding agents aligned with rapidly evolving technologies was another challenge. I used Agent Skills, including SKILL.md instruction files for Google ADK and Google Cloud, to provide my coding agents with specialized and up-to-date technical context. This was particularly useful for technologies where implementation details and recommended practices can change quickly, allowing the coding agents to work from relevant technical instructions instead of relying only on their existing model knowledge.

I also gave the coding agents access to the gcloud CLI as part of the development workflow. They could deploy GeoAgent to Google Cloud, inspect Cloud Run services and production logs, diagnose deployment and runtime issues, implement fixes, and redeploy the application. Combining technical specifications, Agent Skills, development tools, and the gcloud CLI allowed the coding agents to participate in a much larger portion of the engineering lifecycle than simply generating code.

The multi-agent architecture itself introduced another set of challenges. Missions could become long-running and token-intensive, particularly when agents repeated tool calls or performed unnecessary planning and optimization cycles. I added execution controls, validation rules, and bounded replanning to reduce unnecessary computation while preserving the autonomy required for agents to solve complex missions.

I also encountered Gemini capacity errors during end-to-end testing. Because losing an entire long-running mission due to temporary model availability would make the system unreliable, I implemented Gemini 3.5 Flash as a fallback for Gemini 3.6 Flash so execution could recover when the primary model was unavailable.

Some problems only appeared once the complete application reached production. One example was the distinction between server-side Google Maps credentials used by the backend for geospatial services and the browser-side Maps key required to render the interactive map. Debugging these issues reinforced the importance of testing the complete application in its actual deployment environment rather than relying only on local testing.

Building GeoAgent in such a short timeframe ultimately became an exercise in both multi-agent system engineering and agentic software engineering. Detailed technical specifications gave the coding agents a precise implementation target, Agent Skills supplied specialized technical context, and the gcloud CLI gave them direct access to deployment and production diagnostics. Together with automated testing and rapid iteration, this workflow allowed me to move from system design to a deployed end-to-end application within the hackathon window.

Accomplishments that I am proud of

The accomplishment I am most proud of is completing and submitting my first hackathon with a project that represents the level of ambition I want to bring to my work.

I could have narrowed GeoAgent into a much smaller concept to make development easier, but I wanted to push myself and build something technically ambitious. I built a complete multi-agent system combining specialized agent collaboration, geospatial intelligence, operational planning and validation, persistent mission state, live agent activity, a Conversational Agent, interactive map visualization, and production deployment on Google Cloud.

This reflects how I approach projects. I want to keep aiming higher, taking on difficult technical problems, and expanding what I am capable of building rather than automatically reducing an idea to the safest possible scope.

Winning this hackathon is important to me because it would be meaningful validation of that ambition and engineering approach. GeoAgent represents the direction I want to pursue in applied AI engineering, particularly multi-agent systems that interact with real-world data and problems. Having it recognized in my first hackathon would be an important milestone and would push me to set an even higher standard for what I build next.

What I learned

Building GeoAgent taught me that designing effective multi-agent systems is much more than connecting several agents to an LLM. The architecture around the agents matters just as much as the models themselves. Agent responsibilities, context isolation, structured tools, shared state, validation, execution limits, persistence, and observability all have a major impact on how reliably the overall system behaves.

I also learned the importance of balancing agent autonomy with deterministic control. Giving agents too much freedom can lead to unnecessary tool calls, longer execution times, and higher token usage. Adding clear execution boundaries and bounded replanning made the system more predictable without removing the reasoning capabilities that make an agentic approach useful.

GeoAgent also gave me practical experience integrating Google ADK and Gemini with Google Maps Platform and Google Cloud as one complete system. I learned much more about deploying agentic applications, managing persistent mission state in Firestore, handling model availability, working with geospatial APIs, and debugging differences between local and production environments.

Finally, I learned a lot about AI-assisted software engineering itself. Detailed system design and technical specifications made coding agents significantly more effective. Providing them with current technical context, access to development tools, deployment workflows, and production logs allowed me to use them for much more than code generation. They became part of an iterative engineering workflow covering implementation, testing, deployment, debugging, and refinement.

GeoAgent reinforced my interest in building multi-agent AI systems that go beyond conversation and use tools, data, and external systems to solve complex real-world problems.

What's next for GeoAgent

The next step for GeoAgent is to expand from operational planning into planning through execution. Instead of producing a plan and stopping there, I want GeoAgent to track an operation as it unfolds, monitor changes in the real world, coordinate resources, and continuously adapt plans as conditions change.

I also want to expand GeoAgent beyond logistics into areas such as disaster response and humanitarian operations. While I was building GeoAgent, the recent flooding in Nepal made me think about how the same architecture could be adapted for operations such as transporting medical supplies, allocating vehicles and rescue teams, identifying accessible routes, prioritizing affected locations, evacuating people, and coordinating search and rescue.

Disasters cannot be scheduled, but organizations can prepare for them. I want to make GeoAgent event-driven so resources, personnel, locations, procedures, and constraints can be prepared beforehand. Events such as floods, earthquakes, road closures, infrastructure outages, or severe weather could then initiate new missions or trigger replanning using the latest organizational and geospatial information.

Another major direction is expanding the Conversational Agent from Q&A into action. Currently, it retrieves and explains information across missions, data sources, plans, and agent activity. I want users to be able to create and modify missions, update constraints, trigger operational actions, and manage workflows directly through natural language. I also want to enable controlled natural-language database interaction so users can retrieve and update operational information without manually writing database queries.

Beyond developing the technology, I would like to explore working with a local logistics company to test GeoAgent against real operational workflows. I already have experience building end-to-end AI applications for businesses to automate workflows across different industries, and GeoAgent gives me an opportunity to apply that experience specifically to logistics and operations. Working directly with an operator would help identify constraints that synthetic datasets cannot capture, measure where agentic planning provides real value, and guide GeoAgent based on actual operational requirements.

Ultimately, I want GeoAgent to evolve from a system that determines an operational plan into an agentic platform that can prepare, plan, execute, monitor, and adapt real-world operations from beginning to end.