Accessibility Harness & Adaptive Pedagogy for Non-Visual Design Authorship
Architecture assumes you can see. RAP inverts the premise — wrapping an AI assistant around a design that lives in text, so a blind student can author CAD geometry independently in the same studio as sighted peers.
A studio research project co-designed with a legally blind undergraduate architecture student — the project’s primary user — at a major public university’s school of architecture. Open-source; code for the Controller, Watcher, and image-to-tactile pipeline is to be released on publication.
The Accessibility Harness is a configuration pattern, not a replacement CAD app and not a single accessible tool — it is a coordination layer. It wraps a large language model with a sense-agnostic design state, surrounds that state with tactile and linguistic renderers, and treats the student’s spoken intent as an authoring channel. The student drives the work; the assistant is the translation interface to an otherwise sighted-default discipline. The aim is parity, not accommodation: the student depends on the studio’s infrastructure, AI tools, and classmates the way every other student does, rather than on bespoke sighted mediation.
The move
A pattern, not a tool. Swap a renderer or a channel; never rebuild the modeler.
Who
Co-designed with a legally blind architecture student — its primary user. A work in progress.
Runs as
Local-first, command-line + Claude Code, open-source. Exports the state.json and .3dm Rhino 8 rebuilds.
The Harness topology — a swappable LLM engine wrapped by personality, skills, and standards, reached by the student through an accessible web UI.
How it works — Controller, State, Watcher, Channels
The design is a single canonical state.json. A Controller (CLI) edits it, a Watcher rebuilds it in Rhino, and Channels make the AI assistant legible to a screen reader. Everything else either writes to that state or reads from it.
The Harness and its tools — live links (CLI / JSON watcher / Channels), file hand-offs to the tactile printers, and manual studio tools, all organized around the canonical state.
The dominant trajectory of AI-assisted CAD keeps the viewport as the source of truth. RAP makes the CLI the authoring layer instead — and reduces Rhino to one renderer among several that consume the canonical state. Same inputs → same state.json → same geometry, every time.
ROLE 1 · QUERIER
Ask the model
“How many windows are on the east elevation?” — answered from the JSON state, spoken back to verify intent in lieu of viewing.
ROLE 2 · CODER
Edit the model
The assistant drives RhinoPython to change the state — the student authoring through language and structured commands.
ROLE 3 · TUTOR
Learn the craft
It teaches the underlying Rhino and RhinoPython concepts, so the assistant is a bridge to self-sufficiency, not a black box.
The five constitutive properties
The Controller, the State JSON, the Watcher and Channels, the tactile renderers, and the linguistic renderers don’t add up to a single tool — they constitute a pattern. These five properties are what make it one.
01
Sense-agnostic state
The canonical design lives in a JSON file that privileges no modality. Any renderer can be plugged in to consume it.
02
Renderer parity
The visual viewport, the tactile media, and the CLI and web interfaces all consume the same state. The viewport is one renderer among several, not the source of truth.
03
Multiple authoring channels
CLI commands, voice transcribed to CLI, direct JSON edits, and LLM-translated natural-language intent all reach the same state. The student picks the channel that fits the task.
04
LLM skill scaffolding
One model, three scaffolded roles — querier, coder, tutor — so the assistant is a ramp toward independence, not a permanent dependency.
05
Auditability
Every action is reversible and inspectable; the state is human-readable and version-controllable; every command and tool call is logged. “Trust but verify” is enforced by the substrate.
The tools — renderers and channels
The capabilities that hang off the canonical state. Each adds commands without touching the others, and follows one rule: if it can’t be heard, felt, or read by a screen reader, it doesn’t ship.
01
Controller & Layout Jig — the authoring layer
The Controller is a command-line interface the student uses to edit a persistent state.json directly. Commands like set bay A rotation 30 or wall A on express design intent as structured language, and each returns a spoken-style confirmation. The design lives in the JSON as parameters — as pure text — while a small Rhino-Python Watcher reads that state and rebuilds the model. The CLI is the guardrail that lets a blind student drive and inspect geometry without ever touching the inaccessible GUI.
Runs as — a Python CLI (stdlib only) editing the canonical State JSON.
02
Digital Assistant — querier, coder, tutor
The AI layer wraps one model in three coordinated roles: querier (“where is the front door?” — answered from the JSON state), coder (drives RhinoPython to edit the model), and tutor (teaches the underlying Rhino concepts so the student grows toward self-sufficiency). Because default agent terminals are illegible to screen readers, Claude Code’s Channels re-render every turn as structured, navigable HTML — ARIA landmarks, tool calls in disclosures, and a live state.json tree.
Runs as — an LLM (Claude Code) over MCP, surfaced through accessible Channels.
03
Image Describer — drawings into structured text
Architectural images — a plan, photo, section, or diagram — are described as a navigable hierarchy rather than a flat paragraph: Macro (the whole composition), Meso (its parts in moderate depth), then Micro (finer-grain features and measurements). The same schema turns reference images and classmates’ work into something a screen reader can traverse — and, inverted, lets description itself become the act of authorship. Now live as Alt Text, where every parameter of the description — length, emphasis, whether it may estimate a dimension or name a building, how it traverses a space — is a setting the author sets, coaches in their own words, and saves.
Runs as — a vision model with a Whole-to-Part description schema.
04
TACT — tactile graphics (PIAF swell paper)
Converts a design into a physical raised-line graphic readable by touch. Output is laser printed on PIAF microcapsule paper with carbon toner and fed through a heater — the carbon absorbs heat, the capsules swell, and black lines rise off the page as ridges. TACT renders straight from the state file or converts any image with tuned presets, holding black density in the 25–40% band where touch reads best, with Grade-1 (uncontracted) braille labels — BANA-style capital and number indicators, emboss-ready Unicode cells — that stay paper-absolute at any model scale.
Runs as — pure-Python pipeline + its own MCP server (7 functions).
05
3D Print — tactile scale models
Generates a watertight triangle mesh from the same parametric model — no Rhino dependency — validates solidity, and exports a binary STL scaled at 1:200. The printer lives in the studio, not a separate fabrication lab, so the physical object a student lifts off the bed during review stays in sync with the design they are editing by text and touch.
Runs as — pure-Python STL export to a Bambu Lab 3D printer.
The accessible web client — agent turns re-rendered as navigable HTML with a live state tree — beside the Rhino viewport. Image Describer: a perspective photograph and its half-tone tactile translation — tone survives, depth does not. (Notre-Dame du Haut, Le Corbusier, 1955.)
The Desk — where the loop physically closes
Tactile authorship sits at a workstation the team calls The Desk: an all-in-one that co-locates the CLI host, the PIAF printer, a consumer 3D printer, scanning devices, and ergonomic analog tools at fixed positions. A print emerges within arm’s reach; a 3D-printed mass lifts off the bed without changing rooms; the scanner for reading classmates’ work is on the same surface. The loop — author, verify by touch, return to the CLI, revise — becomes one continuous bodily routine rather than a walk between rooms. It is deliberately low-cost and reproducible: any program can co-locate a PIAF and a desktop 3D printer with a CLI workstation, and the rest is mostly software.
Reading a 3D-printed braille / English legend alongside PIAF swell-paper plans and sections at The Desk.
One loop, end to end
Set out a small school, hear it back, and produce something to hold — the command, read, print, feel, revise cycle a studio runs, with the medium expanded rather than removed. (A spoken ADA/egress audit is on the roadmap, not in the grammar yet.)
>> set bay A bays 6 3 OK: Bay A grid = 6×3 modules.
>> corridor A width 8 OK: Bay A corridor width = 8 ft.
>> aperture A add d1 door x 0 2 3 7
OK: Added door d1 to bay A (x-wall gridline 0, 3×7 ft).
>> tactile3d on OK: Tactile-3D export ON.
>> describe # read-only: the Macro / Meso / Micro read-back# then the export buttons write the sheet and the model:# PIAF image → print on swell paper · heat · read by hand# STL / .3dm / state.json → the printer, Rhino, or the desktop Watcher
The argument
Architectural education is overwhelmingly visual. Studio relies on drawings, models, screen-based software, and pin-up critique, and the underlying pedagogy assumes a sighted learner — so for a blind or low-vision student, nearly every routine task, from drafting to peer review, currently requires sighted mediation. Mainstream CAD and BIM tools (Rhino, AutoCAD, Revit, Adobe) tested against the JAWS screen reader are simply not compatible. Incorporating non-visual methods is therefore a precondition, not an accommodation.
Prior accessibility work in this domain has been tool-shaped — a tactile graphic generator here, an accessible CAD substitute there, an alt-text rubric — each retrofitting access onto a pedagogy that itself remains visual. The Harness is different on two counts: it is a pattern, coordinating every tool around one sense-agnostic representation; and it is an accessibility adaptation of the LLM agent-harness pattern, not a parallel substitute that recreates the CAD application.
What the blind case revealed is that design authorship in a digital studio doesn’t have to be coupled to any one channel of perception. Semantic clarity, voice and keyboard operability, an auditable state, deterministic output — these aren’t accessibility features so much as engineering virtues that visual tools abandoned for graphical convenience. Building for the case the default toolchain ignores turns out to build infrastructure other studios should adopt anyway.
The wager
Architecture is inherently multi-sensory. The tools we inherited are not.
What it means for the studio
Four implications the blind case surfaced — offered as candidate hypotheses drawn from a single case over four semesters, not yet a validated portable practice.
An explicit textual design state
A stable, version-controllable, queryable record of where a design stands — supporting voice, CLI, direct JSON, and natural language without ad-hoc adaptation.
Multi-modal critique
Once state is sense-agnostic, critique can run through tactile prints, spoken description, and the viewport in parallel — the pin-up stops being the privileged forum.
AI-scaffolded verification
Ask the model what is actually in your file — “what did I just do?”, “what layer are the columns on?” — grounded in the textual state rather than a screenshot.
Protocols designed for access
“Using your words,” Macro/Meso/Micro alt-text, written notes alongside drawings — communication designed for access tends to beat communication retrofitted for it.
What’s next
The pattern is built to extend — new renderers and channels plug into the same state. On the horizon:
Spatial audio of a design
Binaural rendering — walk a plan and hear volume as reverb, wall proximity as tone, ceiling height as pitch.
Vibrotactile models & haptic gloves
Surfaces and gloves that encode material, load, or edges as vibration you feel under the fingertips.
Live pin-array tactile display
A refreshable pin surface that redraws the current state in real time — a dynamic tactile screen, not a static print.
Live AI scene description
Continuous narration during studio, pin-ups, and site visits via smart glasses — including Socratic questions about the space.
Now live on this site
RAP Studio — drive the pattern from the web
A self-contained RAP Studio now runs in the toolkit: a screen-reader-first web tool where you author a design in structured language — by typed command, by form, or in plain language to the assistant — watch the canonical state.json update as the source of truth, see it rebuilt live in a 3D viewer and as a tactile-style plan, read it back as text and Braille, and export the same state.json, a PIAF swell-paper image, and a 3D-print STL. The state matches the real schema, so it round-trips to Rhino through the desktop Watcher.
Alongside it, Tactile Drawings runs the pipeline the other way: import any Rhino .3dm, give each layer a tactile material pattern from the graphic-texture library, and cut plans and sections anywhere — plus axons and hidden-line drawings, all tunable — exporting millimetre-true SVG plates and 1-bit PIAF swell-paper images, with a full text read-back of the sheet.
And where that one starts from CAD, Tactile Image starts from a picture: drop in a photograph, a map, a scanned plan or a diagram and it is simplified rather than halftoned — tone sorted into a handful of bands, each filled with a texture a hand can tell apart, a groove of blank paper between them, line work thinned and re-drawn at a real ink weight, and everything below what a fingertip can resolve thrown away. The title block carries a key: each texture drawn as a swatch at its true pitch, with what it means beside it in print and underneath it in Braille.
And where those two make an image you can touch, Alt Text makes one you can hear. It is capability 03 above, built: any picture becomes an alt attribute short enough for the web plus the Macro / Meso / Micro bands a listener can step into as far as they want. Every parameter of the answer is a setting — length, what it leads with, whether it may estimate a dimension or only read one off the sheet, how far past the visible it may go, whether it may name the work, how it traverses a space, what it does with colour for a reader who has never seen one — and each setting becomes a rule the describer follows and is then audited against, so an ignored instruction surfaces as a finding instead of vanishing. Coach it in plain language, turn that into standing rules, and save the whole configuration as a preset the studio can share.
Radical Accessibility Project — a studio research project at a major public university’s school of architecture, co-designed with a legally blind undergraduate architecture student, its primary user. The work is in progress; code for the Controller, Watcher, and image-to-tactile pipeline is to be released open-source on publication.
