AWS Builder Center
Agents for Humans: Building Trace to Turn Floor Plans into Tactile Maps

Agents for Humans: Building Trace to Turn Floor Plans into Tactile Maps

I built Trace as a solo project to make tactile-map preparation easier. Here is how I used the Strands Agents SDK to interpret floor plans, review uncertainty, and generate 3D-printable geometry.

A map on the wall is only useful if you can read it

When you enter an unfamiliar hospital, school, or library, one of the first things you need to figure out is where to go. A floor plan near the entrance can show you how the rooms and corridors connect before you take your first turn.
A blind visitor cannot get that same overview from a printed image. They may need to ask for directions or piece together a layout from verbal descriptions.
A tactile map makes a layout readable through touch. Raised lines, shapes, and braille labels represent walls, rooms, doors, and important locations. But making one takes time, needs a specialist, and costs money. Even people who want to make their buildings accessible can hesitate because they do not know where to start.
I built Trace for the Agents for Humans hackathon to make that first step easier: take a floor plan a building already has and turn it into a map someone can read with their hands.

From an uploaded plan to a physical object

The workflow starts with a floor-plan image or PDF. Trace extracts the layout, presents it on an editable canvas, and lets the user correct it directly or describe a change in plain English. It then converts the reviewed layout into raised geometry with braille keys and a legend.
The output is a set of downloadable STL files for a compatible 3D printer. Larger layouts can require multiple tiles. The preparation happens through a web browser on an ordinary computer.
My intended users include schools, libraries, and community organizations. One person prepares the map, but many visitors could benefit from it.

Why Strands became the backbone of Trace

As a solo builder, I needed to spend my time on floor plans and tactile geometry. Strands gave me a consistent foundation for specialized agents, multimodal inputs, and structured responses. I could keep the same agent roles while changing the model provider during testing.
That is the part of AWS open source I appreciated most in this project: useful building blocks that left room for the product itself. Trace needs perception, review, correction, and measured output. Strands helped me connect those responsibilities without giving a model control over the final geometry checks.
I built the agent workflow with the Strands Agents SDK. Each role has a specific responsibility and returns structured data that application code validates.
  1. Read the source. A source reader identifies names, landmarks, and structural details before geometry extraction.
  1. Extract the layout. The parser creates a vector model of walls, rooms, openings, and features.
  1. Review and refine. A critic compares a rendering of the extracted model with the original plan. Targeted corrections preserve records that do not need to change.
  1. Check openings. A separate auditor examines doorways and passages, where an invented gap can change the meaning of a route.
  1. Support human edits. An edit agent translates a request into restricted operations on the model. An ambiguous request can return a clarification.
  1. Resolve layout conflicts. After tactile conversion, a layout agent can propose limited adjustments for elements involved in reported violations. Code checks every proposal again.
The review loops have iteration limits. Routine corrections happen inside the workflow, while uncertain source details remain visible for human review. I create fresh agent instances for each invocation so projects do not share conversation history.
Three stages: Strands source reader, parser, critic and opening audit; human review and edits; tactile conversion, validator, layout repair, mesh and STL export.


Built on AWS open source, with explicit model choices

Strands is the central AWS open-source technology in Trace. I also implemented an Amazon Bedrock provider route, but account access restrictions prevented the Bedrock tests from returning model output.
To continue testing the product, I used Strands with the official OpenAI API. The current local configuration uses GPT-5.6 Sol for visual and spatial work and GPT-5.6 Luna for constrained edits. Bedrock remains an explicit optional route. There is no silent switch between providers when a request fails.
The provider flexibility let me continue improving Trace while retaining the Strands architecture. The live results here use Strands with OpenAI; Bedrock deployment remains unverified.

AI interprets the drawing. Code checks the measurements.

A model can help decide what a line or symbol means. It should not be the final authority on whether two raised features have enough space between them.
I use deterministic TypeScript code for tactile conversion and checks covering dimensions, margins, spacing, and collisions. Export is blocked while those implemented checks report violations. Manifold handles mesh construction, and Three.js provides the preview. The application uses Next.js, Bun, Hono, and PostgreSQL.
These checks are informed by tactile-design guidance. They are not accessibility certification, and they cannot prove that the source was interpreted correctly or that a physical print will be easy to read.

The hardest lesson: a valid file can still describe the wrong building

Turning every visible line into a raised wall would create clutter. The system has to preserve useful structure while removing visual detail that does not belong in a tactile map.
Testing also exposed confident interpretation errors. A reviewer can miss a false wall, and a later agent can repeat an earlier agent's mistake. That is why I compare outputs with the source and keep failed examples rather than treating a successful API response as proof of quality.
Geometry needed its own verification. An early export passed existing checks but contained degenerate triangles. I corrected the mesh construction and checked the downloaded STL bytes independently. A clean digital mesh and a correct map remain two separate questions.

Where Trace stands

Trace has an implemented upload, review, edit, tactile-conversion, and export workflow. Local testing has produced downloadable maps, but difficult plans still expose missing details, unsupported partitions, and layouts that cannot pass the current checks.
I have not yet completed physical-print testing or evaluation with blind readers. Those are essential next steps, along with independent slicer verification and more consistent source interpretation.
Building this alone taught me that the useful outcome is not simply a generated file. It is a map whose structure is accurate, whose raised features are readable, and whose limitations are understood.
My goal for Trace is to make it easier for a place that already has a floor plan to offer a map more people can use.
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