House: Continuity With Jurisdiction

Inspiration

AI assistants can remember too little, remember the wrong things, or use personal context without making it clear where that context came from. I wanted an AI workspace where continuity is useful without becoming invisible or uncontrollable.

House is built around continuity with jurisdiction: residents decide what belongs in memory, what must never be remembered, which model should answer, and when the assistant may search retained conversation history.

What it does

House is a private AI workspace for conversations that benefit from both continuity and competence.

Its core features include:

• Spaces with distinct conversational context
• Editable, resident-controlled Continuity memory
• Never Remember boundaries that prevent automatic recall
• Explicit provider, model, and reasoning selection
• No silent provider substitution or fallback
• Conversation import and review
• Attachment lifecycle and deletion controls
• Rummage, an explicit search across retained conversations

Rummage searches for the resident’s exact words across their conversation history and returns canonical source results. Each result links back to the original conversation, making recalled context inspectable rather than mysterious.

How I built it

House is a React and TypeScript application with Supabase providing authentication and persisted application data, and Cloudflare Workers handling the AI request layer.

During Build Week, I used Codex extensively to design, implement, test, and adversarially review Rummage. The work included authenticated cross-conversation retrieval, result ranking, source navigation, privacy boundaries, provider isolation, lifecycle testing, and protections against persisting sensitive search queries or retrieved excerpts.

GitHub remained the source of truth throughout development. Changes were developed in isolated branches, validated with focused and full test suites, reviewed through draft pull requests, and deployed only after merge.

Challenges

The hardest problem was not finding text. It was defining the authority around finding and reusing it.

Rummage needed to search only conversations owned by the authenticated resident, respect retention boundaries, avoid leaking content through logs or metadata, preserve selected-provider provenance, and return sources that could be independently verified.

An experimental next stage attempted to let retrieved evidence directly ground a persisted assistant reply. Adversarial review revealed that doing this safely requires database-level transaction authority, concurrency control, and durable idempotency—not application-layer approximations. I deliberately did not merge that prototype.

That decision became one of the most valuable outcomes of the week: Codex helped expose where House’s next architectural boundary must live before the feature reaches residents.

What I learned

I learned that trustworthy continuity is primarily a permissions and provenance problem.

A useful memory system must answer:

• Who authorized this information to be used?
• Where did it come from?
• Can the resident inspect and correct it?
• What happens after cancellation, failure, retry, or deletion?
• Which system is authoritative when client and server state disagree?

I also learned how effective Codex can be as both an implementation partner and an adversarial reviewer. It helped build the feature, test failure paths, challenge assumptions, and identify when the correct engineering decision was to narrow scope rather than ship an unsafe abstraction.

What's next

The next architectural step is moving destructive message mutations behind a single database-authoritative transaction contract with serialization and idempotency guarantees.

From there, House can safely extend Rummage from inspectable search into explicitly authorized, source-grounded assistant replies—without sacrificing the resident’s control over continuity.

Built With

• cloudflare
• codex
• github
• openai
• postgresql
• react
• supabase
• typescript
• vite
• vitest
• workers