Nusantara Weather - WebMCP Agent Weather

Inspiration

Indonesia is a country of thousands of islands, diverse climates, and rapidly changing weather conditions. Yet checking the weather often still means opening multiple apps, searching for a city, interpreting forecast charts, and deciding what the information actually means for a trip or daily activity.

We wanted to explore a different experience: what if people could simply tell a weather agent what they need, and the agent could understand their intent, find the relevant weather information, and take action for them?

That idea became Nusantara Weather - WebMCP Agent Weather.

The project was inspired by the emerging WebMCP vision of a web where humans and AI agents can interact through real, useful tools. Instead of building another static weather dashboard, we wanted to create a weather interface that acts as a bridge between human intent and structured weather actions.

A user should not need to know which forecast API to call or which data points matter. They should be able to say:

“Find the safest dry window to travel in Bandung this afternoon.”

And the application should understand the request, gather the relevant weather data, analyze it, and present a useful answer.

What it does

Nusantara Weather combines a beautiful weather dashboard with an agent-ready WebMCP interface.

Users can explore weather across Indonesia by selecting a city or searching for a city through the Find a city interface. The main dashboard highlights five major cities for a clean and focused experience, while typing into the search bar reveals additional Indonesian cities as suggestions.

The application can also understand natural-language weather requests through WebMCP tools.

For example:

“Find the next dry window in Jakarta.”

“Compare Bandung and Surabaya for rain today.”

“What is the safest time to travel in Bali this afternoon?”

The agent can use registered WebMCP tools to retrieve weather information, compare locations, identify upcoming rain windows, and follow the user's intent.

The project includes tools such as:

• get_indonesia_weather — retrieves current and forecast weather for a selected Indonesian city.
• compare_indonesia_weather — compares weather conditions between cities.
• find_next_rain_window — identifies upcoming periods with higher or lower rain probability.
• follow_weather_prompt — interprets a natural-language request and drives the application according to the user's intent.

The key idea is that the user describes the goal, while the agent handles the interaction with the web application.

How we built it

We built Nusantara Weather as a lightweight web application with a strong focus on progressive enhancement and agent interoperability.

The frontend provides:

• A modern weather dashboard
• Indonesia-focused city search
• Top-city recommendations
• Forecast and rain information
• Natural-language prompt interaction
• Agent activity and decision feedback
• Responsive UI for different screen sizes

For weather data, the application uses live forecast information from Open-Meteo.

For the agent layer, we implemented the WebMCP Imperative API using the required tool registration pattern:

await document.modelContext.registerTool({
  name: "get_indonesia_weather",
  description: "Get weather conditions and forecast for an Indonesian city.",
  inputSchema: {
    type: "object",
    properties: {
      city: {
        type: "string",
        description: "Indonesian city name"
      }
    },
    required: ["city"]
  },
  execute: async (input) => {
    // Fetch weather data
    // Update application state
    // Return structured weather information
  }
});

This means the application is not only designed for humans clicking buttons. It exposes structured capabilities that an AI agent can discover and execute.

The architecture follows a simple flow:

Human prompt → Agent intent → WebMCP tool → Weather data → Decision → UI update

We also designed the application with progressive enhancement in mind. The weather website remains usable as a normal website, while WebMCP-enabled environments can interact with the same application through agent-accessible tools.

Challenges we ran into

One of the biggest challenges was designing an interface that works well for both humans and agents.

Traditional web interfaces are usually built around clicks, buttons, forms, and navigation. Agents need something more structured: clearly defined tools, predictable inputs, meaningful descriptions, and structured outputs.

Another challenge was handling natural-language intent.

A request such as:

“When should I leave for Bandung if I want to avoid rain?”

doesn't directly map to a single API call. The system has to translate the user's goal into a sequence of actions:

1. Identify the destination.
2. Understand the requested time period.
3. Retrieve forecast data.
4. Evaluate rain conditions.
5. Determine the most suitable window.
6. Present the result in a human-friendly way.

We also wanted the interface to stay visually simple even though the application supports a large number of Indonesian cities. Instead of showing every city immediately, the frontend focuses on five major cities and reveals additional cities dynamically through search suggestions.

Finally, WebMCP is an evolving part of the web platform, so we had to think carefully about compatibility and progressive enhancement rather than assuming every browser has the same capabilities.

Accomplishments that we're proud of

We are proud that Nusantara Weather is more than a weather visualization.

It demonstrates how a web application can become agent-interactable without sacrificing the human experience.

Some highlights we are especially proud of:

• We implemented real WebMCP tool registration with document.modelContext.registerTool().
• We created multiple purpose-built weather tools instead of exposing one generic API endpoint.
• We added a natural-language follow_weather_prompt workflow that connects user intent to application behavior.
• We created an Indonesia-focused city dataset with coverage across major regions and islands.
• We designed the city search so the interface stays clean while still supporting many locations.
• We built the product around decisions and actions rather than simply showing raw forecast numbers.
• We created a polished visual identity for the project, including a custom Indonesia weather favicon.

Most importantly, we believe the project demonstrates a compelling direction for the open web:

websites that are understandable not only to humans, but also to intelligent agents.

What we learned

We learned that building an agent-friendly web application requires a different way of thinking about product design.

It is not enough to expose data. The application needs to expose capabilities.

A useful agent tool should answer questions like:

• What does this tool do?
• What input does it expect?
• What result will it return?
• Can the action change application state?
• Is the result meaningful enough for an agent to reason about?

We also learned that natural-language interfaces work best when the underlying system is structured and predictable.

The prompt may be unstructured, but the execution should not be.

That led us to a design principle we will continue using:

Unstructured human intent in, structured actions out.

Finally, we learned that great agent experiences should not replace good human interfaces. The strongest experience is one where humans can interact directly while agents can use the exact same web capabilities programmatically.

What's next for Nusantara Weather - WebMCP Agent Weather

Nusantara Weather is only the beginning.

Our next step is to make the agent significantly more capable of understanding real-world context.

We want users to eventually be able to ask things like:

“I have a flight from Jakarta to Bali tomorrow. When is the safest time to leave for the airport?”

or:

“I'm planning an outdoor event in Bandung this weekend. Find the best day and explain why.”

From there, Nusantara Weather could combine weather with additional web capabilities such as:

• Traffic and travel conditions
• Flight and transportation information
• Local events
• Air quality
• Flood and severe-weather alerts
• Tourism information
• Location-based recommendations

We also want to expand the agent from simply answering questions into planning and coordinating actions.

The long-term vision is a weather agent that understands what someone is trying to accomplish, gathers the relevant information from the open web, explains its reasoning clearly, and helps the user make a better decision.

Ultimately, Nusantara Weather is our exploration of a larger idea:

The future web should not only be something humans browse. It should be something humans and intelligent agents can collaborate with.

Built With

• html5
• openmeteo
• webmcp