Personal Practice Intelligence

Practice memory for architects and designers. An agentic teammate for students at heart, keeping the reasoning behind every reference, and recalling it when a similar design decision returns.

Comment

Inspiration

Architecture and design schools teach students to dream a building. Practice teaches them to build one, and that judgment is earned slowly, on site, then leaks away as fast as it is earned. Practitioners and students save thousands of references, but the reasoning behind each save quietly disappears. PPI started from one frustration: the moodboard survives, the judgment behind it does not.

What it does

PPI is an agentic teammate for small AEC practices and the students at heart inside them. The user captures a practice moment by uploading an image, attaches what caught the eye and what to remember later, and Object Intelligence distills a structured memory that the user reviews and edits in their own words before saving it to a private library. When a similar decision returns, the user recalls the saved judgment in plain language. A perforated facade panel study, computed live by Rhino.Compute, can also be explored in-product, orbited and inspected part by part.

How we built it

The app is a no-build, browser-global surface in vanilla JavaScript and HTML, for speed for this hackathon. Object Intelligence runs server-side: the browser sends an image and context to a hosted Supabase Edge Function, which calls OpenAI for a structured memory suggestion validated against a strict schema. Keys never reach the browser. Memories persist in a Supabase Postgres table under Row Level Security, and original uploads live in a private storage bucket, replayed through short-lived signed access.

The interactive geometry runs on a live Rhino.Compute service provisioned on a VM: geometry requests from the OpenAI inference is solved by Rhino.Compute, streamed back as a Draco-compressed model (definitely can still be compressed further!!), and rendered in the browser with three.js so it can be orbited and inspected part by part. For this hackathon the live compute is deliberately scoped to perforated facade panels and gated behind explicit scale questions, so each result is bounded and real rather than an unbounded claim. Hosting is on Vercel.

Challenges we ran into

The hardest part was time... hahaha. Beyond the fact that it is easy to let a model assert what something is, it is much harder to keep it bounded to a suggestion the practitioner authors. Hence we built a strict server-side schema, explicit non-claims, and an automated verifier that fails the build if the copy ever overstates what the system proves.

The toughest engineering was bridging two worlds against the clock. The geometry engines live in Rhino, a C# and .NET runtime, while the app is web and JavaScript, so getting a parametric definition to solve in that C# world and stream clean geometry back into the browser meant constantly jumping between very different loops, with the deadline closing in. We refused to fake it, and we got it working. Live Rhino.Compute now runs on a VM, wired into the app and scoped for the hackathon to perforated facade panels, returning real geometry rather than a promise. Keeping the deck, the README, and the running app all telling exactly one honest story took as much work as the features.

Accomplishments that we’re proud of

The loop holds end to end: capture, context, distilled memory, human review, save, reload-replay, and recall. It runs in the product today, with geometry computed live by Rhino.Compute that a user can explore and inspect. Most of all, it stays honest. Every evidence surface is bounded, and the product never claims more than it can show. In a field of overclaiming AI wrappers, that restraint is the moat.

What we learned

Practitioners and students keep naming the same gap: references are everywhere, but the reasoning is not. The valuable artifact is not the image, it is the judgment behind it, kept in the practitioner's own words. We also learned how much trust depends on visible boundaries. Saying clearly what the system does not do is what makes the rest believable.

What’s next for Personal Practice Intelligence

This hackathon proved the AEC stack can be decoupled from the office, with real geometry compute behind a calm, user-facing app usable beyond the desktop. Native iOS and Android come next, so capture and recall happen on site, in the pocket where the work actually is.

From there, PPI becomes the taste and preference layer for Agentic Colleague, our governed agentic system for AEC teams. The judgment saved here, what mattered and why, becomes the memory that guides real design, BIM, and documentation work across tools, always under human review. Practice memory is how an agentic colleague learns a practitioner's standards before it ever touches a project.

p.s. post-hackathon, a more stable build for demo testing coming round this week!!

Built With

Share this project:

Updates