HELLOBUSAN

Let your Agent use Busan through WebMCP. You set the intent, the Agent acts, and you stay in control.

Comment

🌊 HELLOBUSAN: The WebMCP Agent Governance Platform

💡 Core Question: "What if a city becomes machine-readable for AI agents, while humans retain absolute control?"

🚀 3 Key Breakthroughs:

  1. 🌐 WebMCP City OS: Replaces unstable DOM scraping with 10 explicit WebMCP Tool schemas.
  2. 🔐 Agent Wallet: Granular permission boundaries (Read: ALLOW / Book: ASK / Pay: DENY).
  3. ⚡ Empirical Proof: 84% faster execution & 0% DOM parsing failures.

Inspiration

AI agents are becoming capable of reasoning, planning, and taking actions on behalf of people. But most websites are still designed only for humans.

I asked a simple question:

What if a real city could become usable by AI agents, without taking control away from people?

This question led me to HELLOBUSAN.

I chose Busan as my real-world testbed because a single human goal can require many different services: discovering places, checking events, comparing restaurants, calculating routes, managing time, estimating costs, and eventually making reservations.

Normally, people have to move between many websites and applications to complete these tasks.

I wanted to explore a different model:

The human expresses the goal.

The Agent handles the complexity.

WebMCP connects the Agent to real web capabilities.

The human remains in control of consequential actions.

HELLOBUSAN is therefore not just another AI travel planner.

It is an experiment in designing a new relationship between Humans, Agents, and Cities.

What it does

HELLOBUSAN allows a person to describe what they want to accomplish in natural language.

For example:

“Plan a six-hour rainy-day trip in Busan for my family within a ₩50,000 budget.”

Instead of manually searching multiple services, the Agent can use WebMCP tools to discover information and coordinate actions.

The Agent can:

  • Search places, restaurants, and events
  • Retrieve detailed information
  • Check relevant conditions such as weather
  • Calculate routes and travel time
  • Estimate and optimize the budget
  • Build and update an itinerary
  • Coordinate multiple services around one user goal

The key difference is that HELLOBUSAN does not treat autonomy as unlimited permission.

I designed an Agent Permission Model:

Search         ALLOW
Compare        ALLOW
Route          ALLOW
Schedule       ALLOW
Reservation    ASK
Payment        DENY

How I built it

HELLOBUSAN is designed as a WebMCP-based agentic interface with a Cloudflare-native backend.

Instead of requiring an Agent to interpret a website only through visual elements, HELLOBUSAN exposes structured capabilities through WebMCP tools.

My tool architecture includes capabilities such as:

  • search_places
  • search_restaurants
  • search_events
  • get_place_details
  • get_weather
  • calculate_route
  • estimate_cost
  • get_itinerary
  • update_itinerary
  • request_reservation

Each capability has a defined purpose and structured input/output schema.

I separated read operations, reversible actions, and consequential actions so that the Agent's level of autonomy can be controlled.

The application architecture uses:

  • React and TypeScript for the user interface
  • WebMCP for Agent-facing web capabilities
  • Cloudflare Workers for application logic and API routing
  • Cloudflare D1 for persistent application data
  • Cloudflare Durable Objects for stateful trip sessions and coordination
  • REST APIs and structured JSON data for service integration

A key design decision was to make permissions a system-level boundary rather than merely a visual setting.

The interface may show that payment is disabled, but the backend must also enforce that restriction.

I also designed an Agent Activity Log so that users can understand what the Agent is doing instead of experiencing an invisible autonomous process.

Challenges I ran into

The hardest challenge was not generating an itinerary.

It was deciding where autonomy should stop.

Giving an Agent more capabilities is technically attractive, but greater capability also creates greater responsibility.

I identified three different levels of action:

  • READ: The Agent can retrieve and understand information.
  • ACT: The Agent can perform reversible actions such as organizing an itinerary.
  • COMMIT: The Agent performs a consequential action that may affect the user.

The third category requires human approval.

This became particularly important when designing reservations and payments.

I deliberately avoided the assumption that:

“The user asked for a trip, therefore the Agent can do anything necessary to complete it.”

Instead, the system distinguishes between intent and authority.

A user's intention to “plan a trip” does not automatically grant permission to spend money or make an irreversible commitment.

Another challenge was making WebMCP meaningful rather than decorative.

I did not want to build a conventional travel application and simply add a WebMCP label.

The Agent interaction itself had to depend on structured capabilities.

I therefore designed the product around a comparison between conventional web interaction and WebMCP-based interaction, focusing on task steps, tool usage, errors, completion, and human approvals.

Accomplishments that I'm proud of

My biggest accomplishment is that HELLOBUSAN turned WebMCP from a technical capability into a visible user experience.

The user does not need to understand WebMCP.

They simply express a goal.

Behind the interface, the Agent discovers available capabilities, calls structured tools, reasons over the results, updates the itinerary, and stops when human authorization is required.

I am especially proud of the Agent Wallet concept.

Instead of treating an Agent as either “fully autonomous” or “not autonomous,” I give the user granular control over what the Agent can do.

I am also proud of the Agent Activity / Black Box experience.

Users can see:

  1. What the Agent is doing
  2. Which tool it is using
  3. What information it found
  4. What it changed
  5. Which permission it used
  6. Where human approval is required

This makes autonomy visible.

Most importantly, the prototype demonstrates a different philosophy of agentic computing:

The goal is not to maximize what the Agent can do. The goal is to maximize what the Agent can safely do on behalf of a human.

What I learned

The biggest lesson was that the hardest problem in agentic systems is not capability.

It is control.

An Agent that can only answer questions is limited.

An Agent that can take actions is useful.

But an Agent that can take consequential actions without clearly defined authority creates a trust problem.

WebMCP made me think beyond the question:

“How can an Agent use the web?”

I began asking:

“How should the web communicate its capabilities and boundaries to an Agent?”

And then:

“How should a human control those capabilities?”

This led me to a new mental model:

$$\text{Intent} \rightarrow \text{Capability} \rightarrow \text{Action} \rightarrow \text{Approval}$$

I also learned that the best Agent experience should not hide autonomy.

It should make autonomy understandable.

The user should know when the Agent is thinking, what it is doing, what it is allowed to do, and when a decision belongs to them.

This changed HELLOBUSAN from a travel application into an experiment in Human-Agent Interaction Design.

What's next for HELLOBUSAN

Busan is only the beginning.

My next step is to expand HELLOBUSAN from a travel planner into an Agent-ready city interface.

Restaurants, museums, cultural venues, hotels, transportation providers, local businesses, and public services could expose structured capabilities that Agents can discover and use.

Instead of every Agent learning how to navigate every website independently, the web could increasingly provide explicit, machine-readable capabilities.

This could enable a future where a person does not need to understand which website or application to use.

They simply express an intent:

“I need to spend Saturday in Busan with my family.”

The Agent coordinates the available city services within the permissions defined by the person.

My long-term vision is not:

“AI controls the city.”

It is:

“People control their Agents, and Agents make the city easier to use.”

HELLOBUSAN is my first experiment toward that future.

You decide.

Your Agent acts.

Busan responds.

Built With

Share this project:

Updates

Submission history