AWS Builder Center
Hmun — An address for houses that don't have one.

Hmun — An address for houses that don't have one.

Hmun: describe the way to your house once, out loud. An agent turns it into numbered rider instructions plus a Mizo rendering, and gives you a four-character code. Put the code in address line 2 of any order. The rider opens the link and gets the steps, a photo of your gate, a Navigate button, and read-aloud because they're on a two-wheeler on a 1-in-5 gradient.

The last 300 metres: building an address system for a town built on a hill

I currently live in Aizawl, in Mizoram. Ordering anything here involves a step people in most Indian cities have never had to think about: at some point, a delivery rider is going to call you and ask you to talk them in.
Not because they're lost in the general sense. They've found the locality. The problem is the last few hundred metres, and I don't think you can fully appreciate it until you've stood on a slope trying to explain, by voice, which of six similar gates is yours.

A lot of houses here cannot be described precisely

What people give out as an address is really a route:
Ramhlun North, behind the Presbyterian church, blue gate, third house after the water tank.
That's a perfectly good address if you already know the locality. For a stranger it's a paragraph of landmarks with no reliable way to resolve it to one door — and the resident often genuinely can't do better, because there is no shorter true description of where they live.
The natural response is "just send a map pin." I assumed that too. It doesn't close the gap, and the reasons are specific to terrain:
  • A pin is a point, but the route to it isn't a straight line. On a hillside, 20 metres of horizontal distance can mean a different switchback, a different elevation, or a backtrack to find the one staircase that connects them. You can stand 15 metres from a gate and be four minutes of walking away from it.
  • The last stretch often isn't in the map data. Footpaths, connecting stairs and lanes that two-wheelers use daily frequently don't exist as routable geometry, so navigation either stops short or sends you the long way around.
  • Maps are flat and the town is not. Elevation is the single most important fact about getting anywhere in Aizawl, and it's the one thing the map doesn't tell you.
  • Even a perfect pin doesn't say which gate.
So the delivery degrades into a phone call, every time. And that call is load-bearing: the delivery cannot complete without it. The whole system hinges on someone answering their phone while a rider stands on a slope. Miss it — you're in class, you're in a meeting, you're in one of the many dead zones a hill creates — and the parcel is marked address not found and goes back to the hub for a re-attempt tomorrow, or next week.
That round trip is why delivery here takes a week instead of two days. It isn't the highway. It's the last 300 metres.

What I built

The knowledge that solves this already exists. The resident has it. They just transmit it by voice, one rider at a time, live, on demand, forever.
Hmun captures it once. You stand at your gate and say the directions the way you'd say them on the phone. An agent turns that into numbered rider instructions plus a Mizo rendering, and hands back a four-character code:  ZT74 . You put that code in address line 2 of every order you ever place. The rider opens  /p/ZT74  and gets the steps, a photo of your gate, a Navigate button, and a read-aloud button — because they're on a two-wheeler on a 1-in-5 gradient and cannot look at a screen.
No app for the rider. No account. No integration with anyone's ordering system: the code travels inside a field that already exists.
One small design note I'm fond of. Codes use a 32-character alphabet with  I ,  O ,  0  and  1  removed, because a rider copying a code off a cracked phone screen in the sun will confuse them.

The stack

Built for the Build It track — AWS's open-source stack, running entirely on my laptop. No account, no card, no bill.
Strands Agents SDK runs the direction-rewriting agent. This was my first time using an agent framework rather than calling a model API directly, and the part that earned its keep was the provider abstraction:
from strands import Agent
from strands.models.openai import OpenAIModel
model = OpenAIModel(
client_args={"api_key": key, "base_url": "https://api.groq.com/openai/v1"},
model_id=os.environ.get("HMUN_MODEL", "llama-3.3-70b-versatile"),
params={"temperature": 0.2, "max_tokens": 900},
)
agent = Agent(model=model, system_prompt=SYSTEM_PROMPT, callback_handler=None)
I point Strands at an OpenAI-compatible free-tier endpoint because I didn't want the project to require an account to run. Moving to Amazon Bedrock is a provider swap, not a rewrite — which is exactly the property you want from a framework, and the reason to use one at all.
DynamoDB Local is the datastore — the official AWS offline jar, driven through boto3:
ddb = boto3.resource("dynamodb", endpoint_url=ENDPOINT, region_name=REGION, ...)
ddb.create_table(
TableName="HmunPlaces",
KeySchema=[{"AttributeName": "code", "KeyType": "HASH"}],
AttributeDefinitions=[{"AttributeName": "code", "AttributeType": "S"}],
BillingMode="PAY_PER_REQUEST",
).wait_until_exists()
That's the real DynamoDB API, so pointing at managed DynamoDB later is an endpoint change and nothing else.

What fought back

The model is a dependency that fails exactly when you need it most.
My first cut assumed the model was reachable. Then I thought about where this actually runs: a rider halfway up a hill, in the same dead zones that broke the phone call in the first place. An address app that needs the network to show you an address you already saved is an app that fails at the only moment that matters.
So there's a deterministic offline path — clause splitting, filler removal, a Mizo direction phrasebook — and every response carries an  engine  field so you can always see which one served you. Rewriting for that changed the shape of the code, and it's the part of this I'd defend hardest.
The fiddliest piece of the offline normaliser turned out to be truncation. Cap a step at 14 words naively and you get instructions that end mid-thought — "Continue past the". So:
kept = words[:limit]
while kept and kept[-1].lower().strip(",.") in DANGLING:
kept.pop()
Unglamorous, and the difference between an instruction and a fragment.
"Offline" turned out to be a much smaller word than I thought.
I was pleased with the offline story right up until I tested it properly with the wifi switched off — and the microphone stopped working. Chrome's  webkitSpeechRecognition  streams audio to Google's servers; it is not on-device. Browser geolocation on a laptop is wifi-positioning, so that broke too.
Neither is my code, and neither breaks the actual claim: the agent falls back correctly, and my server and database never touch the internet at all. But it taught me to be precise about which layer is offline instead of waving at the whole app. The honest version is that the only thing in Hmun which ever touches the internet is one model call, and that one call degrades gracefully.
Translating badly into someone's own language is worse than not translating.
The offline Mizo output is a keyword phrasebook. It substitutes high-confidence direction words ( turn right  →  ding lamah pan ,  gate  →  kawtchhuah ) and leaves the rest in English. It is visibly partial, and I chose to ship it that way rather than generate fluent-sounding Mizo I can't verify. A confidently wrong instruction in someone's own language is worse than an obviously incomplete one. Full Mizo comes from the agent path.
Two smaller things I was wrong about.
DynamoDB Local is a plain Java jar, not a Docker image. I'd assumed offline AWS work meant containers. It doesn't, which matters a lot on a laptop and on slow internet.
And I nearly designed around a bandwidth number I'd measured once, from one slow endpoint. The real link was ten times faster. Thirty seconds of measurement would have saved a bad architectural decision — I'd rather write that down than quietly forget it.

Where this honestly is

No auth: a code is a capability, and anyone holding it can see the address. That's deliberate for a rider hand-off and wrong for anything longer-lived — Cedar policies are the intended fix. Single region, single table, no rate limiting. Voice input is English and Hindi, because Mizo isn't a supported transcription language anywhere I could find; Mizo is an output language here, not yet an input one.
This is four days of work. But it does the thing: you describe the way to your house once, and every rider after that gets directions they can actually follow — without anyone having to answer the phone on a slope.


Built for Amazon's First Commit hackathon, Build It track. Code:  https://github.com/richaray/Hmun 
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article