own your alpha, not just your privacy

the week the argument went mainstream

for two months we’ve been making one unfashionable claim: the smart move is not to hand your data and your edge to a frontier lab, because the lab can turn around and compete with you. this week the biggest podcast in tech spent thirty minutes making the exact same argument, in front of an audience many times ours.

on all-in ep 279, the hosts and the palantir manifesto they were reacting to landed on a few lines worth writing down:

• “data retention is your treasure. transfer it at your own peril.”
• “why in the world would you ever want to share any proprietary data with them? you are mortgaging your future.” (david sacks)
• the magic box that says “tell me everything you’re doing and i’ll make it better,” then, from the shadows, “i’ve decided to compete with you.” (chamath’s paraphrase of what enterprises are waking up to)

they even put a number on it. chamath’s team ran a real code-migration task, wrapped an open-source model in their own harness, and measured it at 16.4x cheaper than the closed frontier model alone. friedberg’s version was quieter and just as damning: “you can run a lot of the workflows you’re using ai for locally, on a machine in my office.”

none of them mentioned us. that’s fine. we don’t need the endorsement. we needed the argument to stop sounding paranoid, and this week it did.

privacy was never the real prize

here’s the part the mainstream version still undersells. the goal is not privacy. privacy is the small version: you can’t see my notes. the real prize is ownership of your alpha, and underneath that, ownership of your own judgment.

your alpha is the accumulated record of your work: what you decided, why, what you tried, what failed, the context only you have. run that through a rented model and two things happen. first, it becomes their training signal and their roadmap. second, and this is the one nobody names, you slowly outsource how you interpret your own world to a system that also serves your competitor. you can’t rent judgment from the same place your competitor rents it and expect to stay different from them.

that’s why “it runs locally” is table stakes, not the finish line. plenty of tools store your data on your disk and still can’t tell you whether what they stored is true. ownership means the data is yours, the model is swappable, and you can check the memory instead of trusting it.

name the landlord

this is not hypothetical, so let’s use names. on that same episode sacks walked the pattern through anthropic: it watched cursor prove out the ai-coding-assistant market, then shipped claude code. it watched figma, then shipped claude design (its chief product officer sat on figma’s board until three days before launch). then claude science, claude security, claude legal, claude financial. the model layer studies where value gets created on top of it, and moves in. and at the same time dario argues open-source models are “dangerous” and should be restricted. dangerous to whom? not to you. to the business model that needs you to have no other option.

openai runs the same play with a friendlier face. sam offered yc startups two million dollars in free tokens. jason’s read: “there is no free pizza.” free tokens are how the platform gets to see what the next wave of founders is building, early enough to build it first.

here’s the part that matters though: the tools are good. claude code is good, cursor is good, and we ship an mcp integration for them. the move is not to boycott the tools you like. the move is to stop feeding them the one asset they can’t clone off you: your accumulated memory, your alpha, the record of how you actually think. use claude code all you want. just don’t hand it your memory.

they described the enterprise version. here’s yours.

listen closely to the mainstream take and you’ll notice it’s built for the fortune 500: on-prem gpu clusters, a server per employee, roll-your-own model, teams of people to run it. all correct, all out of reach for a person or a small team tonight.

homestead-memory is the consumer version of the identical idea, and it exists right now:

• markdown you own. your memory is plain files on your disk. open them, read them, git diff them, leave any time. the indexes are derived and disposable. it’s your folder.
• verification over trust. memory rots quietly: a note contradicts itself, a source vanishes, a stale value shadows the current one. hsm verify scores integrity from 0 to 100 and exits nonzero on rot, so it gates your ci and your cron like a test suite. no model grading its own homework.
• extraction you can audit. the optional distilled layer pulls facts out with verbatim quotes, checked in code. a claim either cites a real source or it gets dropped. when a value changes, a changelog line records the transition instead of silently overwriting it.

it’s open source (mit), it runs offline, and it plugs into claude code, cursor, and claude desktop over mcp. the model underneath is yours to choose and yours to change.

and the cost math is not close. a cloud memory service bills you for every turn, forever. this writes for $0 and it’s a folder you already own.

sixty seconds to your own receipts

pip install homestead-memory

hsm init   ./my-vault
hsm ingest ./my-vault
hsm verify ./my-vault        # MEMORY INTACT, or you get told
hsm verify --demo            # watch it catch planted rot, live

claude code, cursor, or claude desktop:

claude mcp add homestead-memory -- hsm mcp ~/my-vault

this is the same layer we described in verified memory: stop renting your mind and cross-harness memory continuity, now with a mainstream tailwind behind the idea.

one more thing the labs can’t match: we publish our failures. every benchmark run, including the ones that went badly, is in the repo. a company whose valuation depends on looking infallible structurally cannot do that. we can, so we do. that is the part nobody with a duopoly to protect will ever copy.

the culture caught up to the argument this week. the tool has been ready. stop renting your mind, own your alpha, and make your memory prove itself.

visit the lab →