News flash: AI agents aren’t going to take over the world. (Yet, anyway.) Training them — “harnessing” them, in AI lingo — is a lot of work. But the productivity rewards are real. And we need real people to manage them — which, for me, ultimately meant more work and more productivity.

Here’s what that’s actually looked like inside our firm.

The first week after our underwriting agent was running, it miscategorized a line item. Payroll costs mapped to contract services. Not catastrophically wrong — both hit operating expenses — but wrong in a way that would skew NOI by category. We corrected it and noted why. The agent folded the correction in. That particular error hasn’t recurred.

What automation promises

Automation, in the traditional sense, promises a one-time effort in exchange for ongoing removal of work. You build the system, you turn it on, it runs. Rules apply consistently. Inputs produce predictable outputs. That’s valuable — and it’s exactly what breaks when inputs vary, which in real estate they always do. Every seller’s chart of accounts looks different, every operating statement is formatted its own way, and no two rent rolls tell the story the same.

Rule-based systems can’t handle that variation. They hit an edge case and a human takes over.

Agentic AI handles variation differently — through pattern recognition rather than rigid rules. It can do things traditional automation can’t, and it gets better through use rather than just through deployment. The work is in the training, not the build.

What training actually looks like

We have three coordinating agents running now. Each requires a different coaching discipline.

The underwriting agent processes deal documents and maps them to our model. It learns from category corrections — when it maps a line item incorrectly, we note why, and that mapping improves. After each deal, the agent understands our chart of accounts better than it did before.

The investor OS agent extracts intelligence from meeting notes and updates a structured record of each investor relationship. Its training is continuous in a different way — investor preferences change as fund cycles turn. A capital partner who was actively deploying three months ago may be in a quiet period now. The agent learns from those updates as they’re made. Preferences that used to degrade as they sat unrecorded in someone’s head now get captured and updated in real time.

The deal-matching component sits at the intersection of both. When our underwriting system analyzes a new opportunity, it queries our database to surface the most likely capital partners — by check size, geography, strategy, and the contextual signals captured from prior conversations. The quality of that match depends directly on the quality of both upstream systems. Better investor records produce better deal routing. Better deal analysis produces more relevant matches.

These aren’t independent tools. They’re a system. The value compounds in proportion to the consistency of training across all three. We built three narrow agents rather than one general one on purpose: each works within a context small enough to hold completely, and a specialist that fits its problem outperforms a generalist stretched thin across all the problems.

The management discipline this requires

Running these agents is closer to managing a fast-learning analyst than deploying software. The onboarding requires real effort — establishing the structure of your model clearly enough that the agent has something to learn from, coaching early mistakes carefully, building the habit of noting corrections rather than just overriding them.

The payoff is a team member who retains what it learns and applies it to every deal that follows. After three months of deal-by-deal correction cycles, the agent’s output is materially better than it was at launch. Not because the software updated. Because we coached it.

What an agent doesn’t have is a low tolerance for repetition. People get bored, and rightly so — boredom is what pushes us toward the creative, judgment-laden parts of the work where we can add the most value. The agent’s patience for the repetitive parts complements that; it doesn’t replace it.

What doesn’t change

The agent reflects the quality of its manager. What we correct, it learns from. What we overlook — a miscategorization we don’t catch, an LP preference we don’t update — it incorporates as fact. Judgment about what the system should optimize for still comes from the people running it. So does the decision about when the output is trustworthy enough to act on.

A firm that engages with these tools the way it would engage a new team member will find something that compounds. After a year of that, you have a colleague who knows your business — and a team whose attention is freed for the work only people can do.

That’s the trade I didn’t expect when we started. More work, not less. But the work is the kind worth doing.

Next: what the build process actually looked like — and what we’d say to a firm that hasn’t started yet.

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.