We had a CRM. We paid for it monthly. It was frequently out of date.

This isn’t a knock on the tool — we’ve used several over the years and the problem is consistent across all of them. CRMs require input. Someone has to log the call, update the stage, note that a capital partner mentioned they’re not deploying outside the Mountain West this cycle, or that their fund is in a quiet period, or that they’ve been watching a specific market for three years and would move quickly on the right deal. That input requires discipline. Discipline compounds into friction at the end of a busy day, after a call that ran long, before the next meeting. Six months later the database that was supposed to give you a clear picture of your investor relationships is a patchwork of stale entries and missing conversations. With outdated data, we lose confidence in what it tells us.

The problem isn’t the software. It’s the input model.

What we built

We use Granola to automatically capture meeting notes. We built a layer on top of it — using Claude Code — that runs after every investor meeting without anyone doing anything.

It reads the notes, identifies which capital partners were present, extracts the relevant intelligence — investment preferences, check size ranges, geographies of interest, fund timing, anything substantive that came up — and updates a structured record automatically. By the time Preston gets to his desk the next morning, the log is current. No manual entry. No discipline required. The database stays current because the input problem is eliminated, not managed.

What a CRM field can’t hold

Our prior CRM did store information — contact records, deal history, and basic preferences. What it couldn’t store was the nuance of a conversation. And even when someone took the time to write a detailed note, you couldn’t query it. You could retrieve it if you already knew to look. You couldn’t ask: which of our investors has mentioned an openness to development plays in markets they know well, and whose fund timing suggests they’re ready to deploy? That kind of question requires language understanding across unstructured data — which is exactly what large language models are built for.

The agent captures conversational texture in narrative form. It’s searchable, it doesn’t deteriorate, and it doesn’t leave.

Where it connects to deal execution

When our underwriting system analyzes a new deal, it queries the investor database and surfaces the most likely capital partners for that specific opportunity — by equity check size, geography, strategy, and the contextual signals captured from prior conversations.

The result is a prioritized shortlist based on everything we know about each relationship.

The same infrastructure, a different problem

The same tools that enabled the underwriting agent enabled this one. Granola provides summarized meeting notes. The Model Context Protocol connects the agent to our contact database. Claude Code handled the build. Training this agent was faster — it already had a working model for what knowledge matters and how to apply it.

What’s different about this agent is that the coaching is continuous. Investor preferences change. Fund cycles turn. The agent learns from corrections as relationships evolve, which is what keeps the database genuinely current rather than accurate at launch and stale six months later.

What doesn’t change

The agent only surfaces who to call.

We are the trusted partner in these relationships — and trusted partners are built through years of communication, transparency about outcomes, and ultimately delivery on execution. The intelligence the system provides is preparation. The relationship, and the obligation to perform, is ours. What changes is how prepared we are when we pick up the phone.

Next: what the process of actually building all of this looked like — and what we’d tell a firm evaluating whether to start.

Preston, our acquisitions lead, prompted me to look into AI. He knows my background — I spent a decade as a design engineer before moving into real estate — and he probably wondered why I wasn’t already pursuing these tools more proactively. Fair point.

The problem

The problem we were trying to solve was underwriting throughput. Specifically, every deal maps to our model a little differently. The seller’s chart of accounts is never the same twice. Their rent roll format, how they treat one-time items, whether payroll is one line or four — all of it varies. That variability is exactly what makes traditional automation fail. Macros and templates work when the input is consistent. Real estate deals aren’t. I had tried rule-based approaches before and hit the same wall every time: the moment a deal came in with an unfamiliar structure, the automation broke and a human had to take over.

What agentic AI changes is the ability to handle that variability through pattern recognition rather than rigid rules. More importantly, an agent can be trained on your specific workflow and learns from mistakes as you coach it. When it maps a category incorrectly, you correct it. It usually doesn’t make that mistake again.

The initial work was building that learning environment — establishing the structure of our model clearly enough that the agent had something to learn from. That setup takes real effort. But once it exists, training becomes iterative: run a deal through, review the output, correct what is wrong, run another. Each round the agent performs better. The improvement compounds in a way that is genuinely similar to onboarding a junior analyst — steady growth that accelerates once the foundational understanding is in place.

What we built

We built an agent — using Claude Code — that ingests the full document set for a deal: offering memorandum, operating statement, rent roll. It loads and reconciles the data across those sources, translates the seller’s chart of accounts to ours, and runs the same reconciliation process on the rent roll — normalizing unit types, flagging vacancy inconsistencies, identifying loss-to-lease. Each source is cross-checked against the others. Discrepancies get flagged before they reach the model.

That’s not simple work. It requires holding the full picture in context simultaneously — which is exactly what large context windows now make possible, and exactly what breaks under deadline pressure when done manually.

On a recent 150-unit value-add deal, the agent caught three material issues on the first pass: an occupancy history that didn’t reconcile with the rent roll, a one-time insurance recovery buried in operating income, and stabilized NOI overstated by approximately 18% in the seller’s underwriting. What would have taken the better part of two days took about 20 minutes.

Why this wasn’t possible 18 months ago

I looked at this problem in 2023. The tools weren’t there.

What changed: in March 2024, context windows expanded to 200,000 tokens — enough to hold an entire property package in a single pass. In November 2024, Anthropic released the Model Context Protocol, a standard that lets AI agents connect reliably to external files, databases, and systems without fragile custom code. In February 2025, Claude Code made it practical for a firm without a software development team to build and deploy working agent systems. We built ours over a handful of weekends. It’s in production, processing real deals.

More recently, advances in agentic capabilities — reliable tool use, skills orchestration, the ability to hand off between tasks without losing state — put the remaining pieces in place. The context window got us in the room. The agent architecture made it work.

What doesn’t change

The agent doesn’t replace an analyst. It changes what the analyst does.

Someone still needs to manage it — running deals through, reviewing outputs, catching errors, continuing to coach it when something is mapped incorrectly. That oversight isn’t optional. The agent’s reliability is a direct product of the attention given to training and quality control.

What it handles is the data work: loading, reconciling across sources, translating, flagging. What it doesn’t handle is what to do with what the numbers reveal. Market judgment, broker relationships, the read on a seller’s motivation — none of that changes. What changes is that the analyst who previously spent hours on data reconciliation now applies that time to the work that actually requires them.

Next: how the same infrastructure problem shows up on the investor relations side, and what we built to solve it there.

What I found in real estate is that a project’s feasibility tells you what you can build. It doesn’t tell you what’s worth building. The decisions that shape neighborhoods are informed by context, community, and the history of the places in which our buildings are built — not just capital. Getting the numbers right is necessary. It isn’t the whole question.

The question I’ve been asking since — in different forms, across different problems — is: what is actually worth building?

That question is the premise of this newsletter.

I co-founded Urban Development + Partners in 2006. Since then we’ve developed and acquired urban mixed-use projects across Oregon and Northern California — multifamily, office, hospitality, adaptive reuse — and managed investments through the 2008 crisis, the 2020 dislocation, and the post-pandemic office collapse. We’ve made money, lost money once, and written about both with equal specificity in our investor letters.

We’ve also built intentional cohousing communities from the ground up — working with families and baby boomers who want to live differently than conventional housing allows, and with our friend and colleague Katie McCamant, whose work introduced this model to North America.

This year, I built AI agent systems that now run core workflows at our firm — using tools that didn’t exist 18 months prior. I hadn’t written production code in 20 years. That surprised me about as much as it surprised the people I work with.

Worth Building covers the terrain where all of this intersects.

Housing and supply. Why the shortage persists despite broad consensus that it shouldn’t. What development economics look like from the inside. What policies move the needle and which ones just sound good.

Community by design. What communities should we be creating, and how do we build them deliberately? Cohousing for families and for people planning the next chapter. What it takes to develop a neighborhood for people who don’t yet know each other. Why intentional community works, and why most Americans have never heard of it.

Capital and conviction. The investor’s lens on real estate — acquisition strategy, market cycles, fund structure, the hold/sell decision under pressure. The same transparency I use in our investor letters, applied to questions that don’t require a fund subscription to find interesting.

AI and the built environment. Not AI as concept or hype. What we actually built, how it works, what it changed, and what it didn’t. Practical and specific — written by someone still building.

These aren’t unrelated topics. They’re different angles on the same question.

What housing is worth building? What communities should we be helping create? What investments are worth the conviction they require? What tools are worth the time it takes to build them?

Worth Building comes out monthly. Each issue takes one question, one problem, or one idea and develops it fully — no listicles, no predictions, no five tips. A practitioner’s view from the middle of it.

If that’s useful to you, subscribe. If you know someone for whom it would be, forward this to them.