Most landlords keep a few escape hatches: raise the rent, cut the maintenance, skim the surplus. Liberty Bee gives up all of them. We simulated twenty years, across every funding level and market from calm to crash, to find out whether that can actually last — and we're showing you everything, including the parts that don't flatter us, and where every number comes from.
The problem — and the data behind it
Every figure in this chapter is public data, sourced in the ledger at the end. No made-up averages.
Priced out
of Salem renters can't afford a typical Liberty Bee 2-bedroom1 — and that's already discounted below market. Below-market housing obviously helps them. The hard question isn't whether it helps — it's whether an operator can give that help away and still be standing in twenty years.
The market underneath it
This isn't a feeling — it's the ACS (the U.S. Census Bureau's American Community Survey) and the city's own housing report. The typical renter earns about $58k3; a market 2-bedroom runs around $2,800/month4. Thirty percent of that income — the classic "affordable" line — is roughly $1,450. The going rate is nearly double it.
That's the squeeze Liberty Bee is aimed at: not the destitute — them, honestly, a below-market landlord can't reach — but the working renter for whom "market rate" quietly means shrinking your life.
The idea, the simulation, and what it found
Before the findings: an honest fence around the claim.
First — what this is not
Liberty Bee is not subsidized or income-restricted housing. The baseline model assumes no tax credit, no affordability covenant, no government operating subsidy — because the whole point is to test whether the model itself can stand without them.
And it does not solve poverty. That's a real problem with real, established answers — vouchers, public housing, direct subsidy — and we can't match them as the model stands. The deeply low-income renter needs help no below-market landlord can provide; pretending otherwise would be dishonest.
What it tries to be is narrower and testable: more affordable than the market, free of the usual extractive incentives — no rent hikes on people who stay, no punitive fees, no surplus skimmed off — and still solvent twenty years on. That's the entire claim. Someday a future version might accept vouchers and stack with subsidy; not this one, and we say so on purpose.
The idea
In our original written proposal, the mission was stated simply: provide stable, dignified housing while fostering long-term community resilience.
The idea isn't to make money. It never was. Not much of a sales pitch, we know — but bear with us. The idea is to deliver immediate, meaningful relief against one of the biggest stressors in our society: housing.
The Liberty Bee model isn't about investing in housing — it's about anchoring families, preserving community integrity, and reshaping what affordability looks like. It's a non-extractive, sustainable, community-driven future for housing. It's about investing in the people.
The refusal
Everything else is machinery in service of one idea: the value tenants and a community create should stay with them.
How is this even possible?
Liberty Bee buys its buildings outright — no debt, no lender, no interest payment that has to be met before anything else.
That one fact turns a nice idea into a workable one. A leveraged landlord has to maximize rent and cut corners — the bank doesn't care about your tenants. With no debt, the money that would've gone to a mortgage cycles back into the reserve, the next building, and the people living there. It's also why Liberty Bee can absorb the cost of its own kindness — flat rents, deep discounts, keeping people housed — and just grow slower, where a leveraged operator would default.
No mortgage, so the money stays in the mission.
What we built
Liberty Bee is an event-driven Monte-Carlo engine: twenty simulated years, run across sixteen funding levels and every market regime, from calm to crash. It doesn't argue the idea works — it stress-tests it, and reports what happened, including the runs that died. Every number below is one of those outputs.9 How it's built and how to reproduce it is chapter 04.
Finding — does it survive?
Start with too little capital — around $2M — and almost every version runs out of money before year twenty. Just 2% make it.
Add capital and survival climbs steeply: $3M → 54%, $3.5M → 80%, $4M → 92%. A narrow band turns an under-funded experiment into a durable institution.
At $4.5M, every single run survives the full twenty years — and the portfolio grows from about 19 homes at the threshold to ~65 at the top of the range, holding the below-market rule the whole way.
So the story isn't "does non-extraction work?" It's "how much runway does it need?" — and now we can put a hard number on it: $4.5M.
Finding — how long it lasts
Survival isn't just a yes-or-no at year twenty. A thinly-funded org can look fine for a few years, then run its reserves down and collapse. Here's the share of runs still solvent at each milestone, by starting capital:
% of 50 runs still solvent · $4.5M and up hold 100% at every milestone · engine 0.5.0
At $2M, nearly half make it five years — but almost none reach ten. At $3M, most last a decade, then attrition sets in (54% still standing at twenty). Only past the $4.5M threshold does an org hold the line the whole way. Thin funding doesn't fail loudly up front — it bleeds out quietly, years in.
Finding — how far can it push?
How deep a discount can Liberty Bee give before the math breaks? We swept it — every discount depth against every funding level. The pattern is clean: generosity is bought from the balance sheet at a knowable price.
■ survives ■ fails · % of 10 seeds surviving 20 years · engine 0.5.0
Every ~5 points of deeper discount raises the capital you need by roughly $0.5–1M.10 Past a point, no amount of money buys a half-off-forever policy — a 50%-off-forever policy survives at no funding level we tested, even $11M. That's the quantitative case for the discount we actually chose.
Finding — who it's for
Solvency is the floor, not the goal. So the model measures the thing that actually matters: how much better off tenants are.
That savings is real money that stayed in the community instead of leaving as someone's profit — and it compounds: the longer you stay, the deeper your discount gets.
In-kind housing help is a famously inefficient transfer — economists find it can cost a provider more than a dollar for each dollar a tenant truly values (the classic estimate is ~2.4×15). We won't pretend otherwise. What our model can measure is the straight transfer — every dollar Liberty Bee gives up in rent is a dollar a tenant keeps. What it can't measure is how much a tenant privately values that housing versus cash — so we don't fake that number, or put one on what a cash check can't buy: stability, not being displaced, roots.
Finding — reach
Every extra dollar of starting capital buys more buildings — and more households housed below market. That's the case for funding it properly: it isn't overhead, it's people. At the $4.5M survival threshold a surviving org houses about 55 households over twenty years; at $11M, about 172.
Households housed below market per surviving org over 20 years, by starting capital · green = the $4.5M threshold
Finding — the deal deepens
Your rent is frozen the day you sign — while the market keeps climbing — and the discount steps deeper at years 3, 6, and 10. The guaranteed ladder alone:
Below-market discount by tenure — the shipped 10% up front plus a 5 / 5 / 10 tenure ladder.
And because a sitting tenant's rent never re-prices while the market inflates, the real gap grows even faster than the ladder promises. In dollars, the median tenant's cumulative savings:
By year 5 the typical tenant has saved about $46k; by year 10, $140k; a twenty-year tenant, past $500k — money kept in a household instead of leaving as someone's profit.
Tenant credits
Beyond the rent discount, Liberty Bee banks 10% of every on-time rent payment into a Tenant Credit that belongs to the household. It's not cash, not a loan, not equity, and it can't be sold or transferred away.
How and when you use it: once a year you can draw up to a month's rent from your balance — either as a routine credit toward a month you choose, or as hardship relief when a month goes sideways. When you move out in good standing, whatever's left can go toward your final month's rent, and it stays redeemable for two years after you leave (an eviction forfeits it). It only ever builds on rent paid on time, and it never touches damages — that's what a deposit is for.
It's also where the model is least finished — so here's the honest split of every credit dollar earned across the corpus:16
Only about half of what tenants earn actually reaches them; a fifth is forfeited outright. We're not spinning that as a win — it's a design problem we're naming out loud, and making the credit easier to use is on the list.
Finding — the bottom line
Put it together — below-market rent plus credits actually redeemed — and you can watch the total value kept in the community instead of extracted as profit, piling up over twenty years. More starting capital doesn't just serve more people; it keeps more money local, and the gap widens every year.
A properly-funded org at the $4.5M threshold keeps about $5M in the community over twenty years; at $11M, over $13M. None of it leaves as someone's return.
Finding — why people stay
The whole theory of change is a loop: a below-market deal that deepens with tenure means the longer you stay, the more you'd give up by leaving — so people put down roots, and stability compounds. This isn't just hope — below-market tenants are measurably about 19% less likely to move13. The model captures it directly: your odds of leaving fall as your deal gets better.
We're honest about why people stay — and it shifts over time. Early in a tenancy, "nowhere else affordable to go" is a big part of it: the discount is still shallow and the market is tight. But as your below-market deal deepens with tenure, the deal itself becomes the reason. Averaged across a whole tenancy, that "nowhere to go" constraint accounts for about 44% of why people stay — a large minority, but the deal itself is the bigger half.14
But let's be real: "nowhere to go" is only a win for a traditional landlord. Our goal isn't captive tenants. Yes, it keeps people in the Liberty Bee system — but that's not why we want them here. It's a symptom of a broken housing landscape, and even where it "benefits" us on paper, we'd far rather people stay because they want to than because they have nowhere else to go.
Blueprint, not a building
There is no funded Liberty Bee. No buildings, no tenants, no bank account. Right now it's a model — a rigorous, reproducible argument that the idea holds up.
Most housing pitches ask you to trust a vision and write a check. We'd rather prove the thing survives twenty years of simulated pressure first, in the open, before anyone risks a dollar — or a home — on it. Having done that, the honest answer to "so what's missing?" is one word: deep pockets.
The model runs on buying buildings outright — no debt — which takes real money up front, and we have exactly none. But it already shows how much it takes (about $4.5M to clear the survival threshold) and that it holds. So this isn't a plea for faith — it's a number, a method, and a result anyone can check, and then capital. Nothing else stands between the model and a real operation.
The tech, and the receipts
How it's built, where the code lives, and every number's source.
How it's built
Liberty Bee is an event-driven Monte-Carlo simulation engine — Python 3.12 + SQL Server — that plays out 240 months of housing operations per run: acquisitions, leases, renewals, maintenance events, inflation regimes, tenant retention. Every random draw comes from a recorded seed, so any run — a survival, a death, one tenant's discount schedule — can be reproduced exactly by anyone with the code.
Take it. Change the assumptions you doubt. Run it against your own city. If we got something wrong, this is how you'll prove it. And this is how you'll let me know: gray@libertybee.org
Under the hood — the property market
Liberty Bee doesn't hand itself buildings. It runs a simulated property market that behaves like a real one: listings appear and disappear on a daily clock — more of them in the busy season — each priced from real local sales data and sized by real unit counts. Every building carries a days-on-market and a hold-period drawn from real distributions, so some sell fast, some linger, and owners sit on a property for years before it comes up again.
Against that market the operator does what a careful buyer does: watch what's available, value each property on its rents and its condition, and buy it outright when the numbers work and the cash is there. There's no auto-granted portfolio — every acquisition is a decision the model has to be able to afford, which is exactly why the starting-capital question has a hard floor.
The market's inputs — prices, rents, listing volume, days-on-market, seasonality, how long owners hold — are all calibrated from public real-estate and housing-market data for the Salem area. Where a number is a local market observation rather than an official statistic, we treat it as a calibration input, not a published claim — the goal is a market that behaves like Salem's, not a listings database.
Under the hood — inflation
Plenty of housing models pick one inflation number — say 3% a year — and let it ride. That single assumption can make an operator look invincible: a steady rate never produces a bad year. The world doesn't work that way. Neither does our simulation.
Instead, the model treats the economy as a set of regimes — calm stretches, rent surges, financial downturns, post-shock recoveries — and moves between them month to month, the way real markets do. And critically, everything inflates on its own track: rents, operating costs, property values, and vacancy don't march in lockstep. We model that because that decoupling is exactly what hurts a real operator — in a downturn, property values fall and vacancy climbs while taxes and insurance keep rising anyway. So we model it honestly.
The regimes are calibrated from real federal inflation and housing-price history. There have been only a couple of genuine crises in the last forty years — too few to simply resample — so how often a downturn strikes is a modeling decision we make to the best of our ability, not a statistic we can pretend to have measured. When we say "every market regime, calm to crash" that means something here, because the model has to survive surges and crashes, not one flattering straight line.
Built the hard way
A model is only worth trusting if the people building it try to break it. So we do — and when we find something wrong, it goes on the page, even when the fix makes our numbers worse. A sample of what we've caught:
The full, current list — every defect we know about, its cause, and its fix status — lives on the known-issues ledger. It only ever grows more honest.
Where it isn't finished
The model isn't flawless. What we'll stand behind is the direction: every pass makes it more real and more mission-true — even when that's less flattering to us.
Where the model goes next
Making it real takes capital. Making the model richer is a separate roadmap — future versions, not things standing in the way. What's on deck:
Beyond the frozen baseline — live, not cited
Everything above this line is frozen — 800 runs, every number reproducible from a seed, and none of it will ever move. Everything below this line is alive. The same released engine keeps running on a machine in the corner of a room, on fresh seeds no cited run ever used — not to change the answer, but to keep measuring it.
Live runs paused · cutting a new baseline
We're formalizing a new set of numbers.
When a new baseline is cut, the live runs pause while the new engine version is re-run end to end — a half-finished baseline is never shown here as live. Throughout, the shipped version's complete record stays on the version archive; when the new baseline is live, the live numbers return here, on the new version.
Right now the next baseline is being cut on the newest engine version being prepared for release. Liberty Bee 1.0's full living record — 5,903 fresh-seed runs, every rung, both scenarios, the fuller picture the frozen 800 couldn't show — is on the version archive →.
A living run: engine 0.5.0, a fresh seed no cited run ever used, a fresh database restored from the released Gold every time, keyed (scenario · engine · funding · seed). Published only through a tripwire-gated, human-merged pull request — eight invariant checks stand between the machine and this page. Data contract: data/schema.md.
Questions, and the person
First the objections, straight. Then why Salem, and who's behind this.
Preemptive answers
Fair objections deserve straight answers — tap any that's on your mind.
If by socialism you mean state or collective ownership of the housing — no. Tenants aren't collective owners, the state doesn't operate the properties, and the model doesn't abolish rent, contracts, property ownership, or cash flow.
If by socialism you mean any system where value benefits ordinary people instead of flowing upward to private owners — then the word is being stretched too broad to be useful.
Liberty Bee operates inside a market economy. The difference is simply that surplus stays inside the housing system instead of being extracted upward.
It operates inside capitalism, yes — that's the point. We're not pretending market constraints disappear. It uses ownership, rent, contracts, pricing, reserves, and cash flow. The difference is that surplus is retained inside the housing system instead of taken as private gain.
A free market doesn't require every participant to use the same model or profit strategy. Liberty Bee is just a different operating model within a proven market — and the market can judge whether it works.
Operationally, sure. The difference is governance and use of surplus. A conventional landlord extracts surplus for owner return. Liberty Bee retains it — for reserves, maintenance, affordability, tenant stability, and disciplined growth.
Because it's a testable alternative sitting between conventional rental extraction and subsidy-dependent affordable housing. We're not asking funders to fund a vibe — they'd be funding a model with explicit assumptions, defined failure conditions, and reproducible simulations.
Because rent has to cover real costs. Set it below operating reality and the model collapses — that's exactly what the survival curve up in chapter 03 is showing you. Liberty Bee starts below market, then deepens affordability through tenure-based reductions and retained surplus only when the system can carry it.
The model can't fix that — the rules and the people have to. A humane system is not a naive one. Liberty Bee needs clear screening, lease enforcement, a hardship policy, reserve rules, and honest failure conditions.
No. Charity is episodic relief. Liberty Bee is institutional design — it uses housing cash flow to create durable affordability, without requiring every operating dollar to come from donations.
First — we'd have to have grants. This version of the model doesn't include grant funding at all; it's on the books for a future iteration. And even then, grants would be acquisition accelerators, not operating life support. If operations need grants to survive, the model is broken — which is exactly why we didn't build them in.
Ownership isn't automatically stability or benefit. It adds responsibility, risk, maintenance, taxes, insurance, financing, and legal complexity. Some tenants want ownership — it's part of the modern American Dream. Some have no desire to own. Some just need stable rental housing.
Liberty Bee can support pathways to ownership without pretending ownership is the only valid form of housing security.
Why Salem?
One — because a made-up town proves nothing.
Every number in chapter 02 comes from one real place. We didn't pick an easy market to look good — Salem is hard: tight, expensive, fast-gentrifying, homes pricey enough that buying them outright takes real capital. If a non-extractive operator can make it here, that means something. If it can't — far better to learn that in a simulation than with people's homes. And every one of those numbers is a knob, not a law: point the model at your city and run it.
Two — because I want to live there.
Let me switch from Liberty Bee to myself for a moment.
Back in 2024 we — my wife and I — decided that once our kid goes off to college, we're moving to Salem. I love the city. The community, the culture, the diversity, the history, the architecture. Walking through the empty streets at night and standing barefoot in winter-cold water before the sun rises. I've never felt more at home.
So we started talking about how we could make money. In a tourist town, when you have a little capital you could leverage, an obvious answer is Airbnb. Which was… fine… for a bit. But the more I thought it over, the more uncomfortable I got.
Eventually I realized why. If I truly loved Salem for all the reasons I claimed to, why would I actively pursue the one thing that's anathema to the greatest part of what I loved — the people?
So I started thinking of ways I could be a positive part of the community instead. This idea rose from that. That's why Salem.
Why you should trust me
You shouldn't.
I'm a baby born in a bus — because that's our home. I'm a kid watching his mom work like hell to give her children a better life. I'm a young adult with shady side-hustles just to make rent. I'm a guy begging for jobs and opportunities to learn. I'm a husband and a father and have far too many little furry animals in my house. I'm working long hours to make ends meet and keep the wolves away. I'm a man with a crazy idea about housing that won't leave his head... so I built it. Tested it. More than two years since I started my first attempt at expressing it... over a year and a half just on this version... But I built it. And laid it out here for you to see.
I'm just a guy.
But maybe I'm like you.
Where I don't have cash, I've got brains, sleepless nights, and data.
That doesn't mean you should trust me. And I'm not asking you to.
Trust the data.
The chance of anyone handing me millions of dollars and telling me to put this into action is… non-zero. So the next best thing is for me to take my idea and put it out there publicly.
Take the data. Take the code. Run it yourself. Tweak it. Change it. Poke holes in it.
Maybe some altruistic billionaire will take it and run with it. Probably a non-zero chance of that as well.
One last disclosure
Here's the honest story of how this exists.
I built the first version from scratch, by myself, in T-SQL. Those of you who know are probably thinking to yourselves, "gross" — and I agree. It was rough. And deeply, deeply flawed. But I'm a SQL Server DBA turned Data Architect. I've developed as needed throughout my career, but the gaps in my knowledge would never have allowed me to build this in any reasonable time. As of this moment, it's been over a year and a half of development. So don't come at me saying, "well, you could've just learned Python." Yeah, I could have. I could have learned Python and data science. And instead of reading this page now, you'd be reading it four or five years into the future.
What carried it here is that I took what I've learned from watching brilliant project managers and developers work at other companies. Through fits and starts, I learned to run AI the way a project manager runs a team of developers: I set the direction, made every ruling, argued the philosophy, hunted down the overclaims, did the UAT, performed code review where I could, and held the line on honesty — and the AI did the heavy lifting of code, analysis, and grind. The idea, the mission, and the call on every honest-versus-flattering tradeoff are mine. The execution was a partnership.
AI is very divisive right now. I could just as easily have said, "yeah, look what I did." But that runs counter to everything I've been trying to do. Honesty without flattery is the whole point. I can't tell you how many nights we fixed a problem and that fix caused massive shifts in the simulation's outcomes that left me feeling thoroughly defeated. Hell, the first part of this year was almost no active development. Just me, in my feelings. The only reason I picked this back up the last time was that I finally decided it was worth just getting to a completed state and putting it out in public — maybe the failed idea would still benefit someone. And then I'd never think about this stupid thing again.
And that's the point. It's more important to be honest and real than to just sell a perfect picture. So, yes — AI was instrumental in making this happen. This project is what one determined person with a clear idea and the right tools can build now (also, I learned what an em-dash and an en-dash were — and maybe AI teaching us how to actually use our language isn't so bad… now if I could just master the semicolon). You don't have to take my word that any of it holds up. The rules are written down, the code and data are downloadable, and every number re-runs from a seed. Check it yourself. That was always the deal.
Get in touch
Liberty Bee is a public work in progress, built in the open. Found a flaw, want to point the model at your own city, or want to talk about funding a real one? Reach out.
Sources & methodology
Two kinds of number live here: public data anyone can look up, and our model outputs anyone can reproduce. Both are traceable to a tracked source in our documentation.
Full provenance, with verbatim quotes against link-rot, lives in evidence_base.md in the repository. This ledger is the site's window onto it.