Anzhu: Housing Decisions, Mapped

Inspiration

A family housing decision is rarely just “Which home should I buy?” It is a coupled decision involving the current home, cash and mortgage pressure, school timing, commute, care for children or parents, renovation, and sometimes a transition rental. The better the advice, the more sensitive the data becomes.

I first imagined Anzhu as a fully hosted real-estate agent. That exposed the central product problem: users should not have to hand an enterprise AI their family balance sheet and life plans just to receive useful guidance. I changed the architecture from an agent that owns everything to a local-first Skill that lets the user choose the host model while keeping deterministic planning state on their own machine.

What it does

Anzhu is a Codex Skill and interactive housing-planning workbench. The user talks naturally with Codex about their current home and family constraints. Codex and GPT-5.6 handle conversation, clarification, research, and recommendation reasoning; Anzhu turns the result into a structured, inspectable visual plan.

The workbench can:

• record the current property and key household constraints;
• place verified assets, communities, schools, and rentals on an interactive map;
• connect them with meaningful route sequences;
• show evidence cards that explain each option’s relative advantage;
• let the user “ping” an entity or need, promoting it into a strong planning constraint;
• compare buy-first, sell-first, rent-transition, and wait scenarios;
• generate detailed plan cards with rationale, timing, cash-pressure, commute, school, and disruption tradeoffs;
• play an optional scene-based voice walkthrough synchronized with map markers and routes;
• export the resulting plan while keeping each Codex conversation in an isolated local session.

How it works

The architecture deliberately separates flexible intelligence from deterministic execution:

1. Codex owns the conversation. GPT-5.6 understands incomplete human language, asks the next useful question, researches coordinates and evidence, and reasons across competing family goals.
2. A strict Skill contract is the boundary. Codex emits structured patches such as facts, markers, evidence cards, routes, plans, and narration scenes.
3. The local workbench owns state and rendering. A bundled Next.js application validates every patch, writes per-session JSON locally, and renders the map and plan UI.
4. Guardrails make the output auditable. The contract rejects missing coordinates, vague rental areas, unsupported polygon patches, mismatched entity cards, fabricated plan generation, and plans without visible rationale.

There is intentionally no hidden server-side chat model inside the workbench. Sensitive planning state stays local. The only optional external AI call is explicit narration audio generation.

Built with Codex and GPT-5.6

Codex served both as the development partner and the runtime host. I used it to translate the product concept into the Skill boundary, iterate the structured contract, implement the Next.js workbench, and turn failure cases into regression tests. At runtime, GPT-5.6 provides the flexible reasoning that a rigid form cannot: it catches ambiguity, distinguishes hard constraints from temporary worries, and produces structured updates that the Skill can validate and reproduce.

This division was the key design decision: the model remains expressive, while the user-visible state changes are deterministic and testable.

Challenges

The hardest challenge was preventing a polished demo from becoming an unreliable “AI map.” Every visual claim needed an explicit contract. A recommended school must appear as both a real coordinate and an evidence card; a selected target must be promoted from “recommended” to “target”; a plan may only be generated after the user explicitly asks for one; and every pinned item must remain visible in later reasoning.

A second challenge was session isolation. Each Codex conversation receives its own visual session ID, so real planning data never leaks into the mock demo or another conversation.

A third challenge was preserving a warm conversation while enforcing strict machine rules underneath. The user should feel heard, not feel like they are completing a database form.

Accomplishments

• A runnable, installable Codex Skill with its own local workbench.
• A coherent end-to-end product experience across conversation, evidence, map, routes, plan cards, and narration.
• Local-first per-conversation state with a blank normal mode and a separate mock debugging mode.
• A contract-driven safety layer backed by 85 passing automated tests.
• A reusable architectural pattern for other sensitive consumer decisions: let the model reason, but let deterministic software own consequential state changes.

What I learned

The best agent architecture is not always “more agent.” For private, high-stakes consumer decisions, trust boundaries are part of product design. A Skill can provide reusable expertise without becoming the custodian of a user’s private life.

I also learned that guardrails are not a limitation on model creativity. They are what make the model’s creativity usable over time.

What's next

Next I would add opt-in policy and listing connectors with explicit provenance, encrypted local state, richer scenario comparison, and an English demo dataset. The same contract-first approach could extend beyond housing to family finance, elder care, and other decisions where flexible reasoning and privacy must coexist.

Built With

• codex
• gpt-5.6
• maplibre-gl-js
• next.js
• node.js
• react
• typescript
• zustand