I'm Trying to Build a Mind on Hardware I Own. I'm Not There Yet, the hard part begins now.
A year of homelab memory, an adversarial AI team, and a private assistant that still confabulates when I push it. Here's the real scorecard — including what still fails — and why I keep going. This is not a blueprint.
Where this comes from
If you've been following the series, you already know the arc. I built a homelab that just kept growing because I was tired of renting everyone else's infrastructure. I built persistent AI memory because I was tired of agents forgetting what we'd decided ten minutes ago — durable stores for decisions and relationships so agents share one brain instead of starting from zero every session.
None of that started as a research project. It started as a database guy getting annoyed.
I've been circling the same idea for longer than the 3k1o blog — open-source models, ownership, the boring infrastructure that makes AI useful. (If you only know me from the MySQL side, that trail is on Another MySQL DBA.) This is not a rebrand. It's the same stubborn preference: own the stack, inspect the truth, don't trust a black box with your working life.
What I didn't write much about for a while: somewhere along the way, "my agents" became a team. Developers. A reviewer. A critic that refuses to rubber-stamp anything without live proof. They coordinate through shared state, not through me copy-pasting between terminals. And off to the side, a private assistant that watches systems, cleans the spam, and tells me when something in the lab breaks because I did something stupid.
I built all of that because I needed it — not because a paper told me to. This year the failures got honest enough to write about, without handing the internet a how-to for the parts I still consider private.
What I'm actually trying to do
I want to be precise, because this is the part the internet gets wrong.
I am not trying to build a better chatbot. I'm not wrapping a frontier API in a voice UI and calling it a coworker. I'm not building an all-knowing AGI god for the planet.
I'm trying to build a private mind — on hardware I own, on weights I can inspect, that can't be switched off by someone else's policy change. Something that doesn't only answer when poked. Something that knows what it doesn't know, reaches for the right resource, and occasionally acts because it decided something needed doing.
Not "do this at 3 AM." <-- this is cron or system timers
"I need to do this — it's been a while." <-- This is a mind
That's a much harder bet than a task runner with a personality wrapper. And I'll say the quiet part out loud: I haven't pulled it off yet.
I will come back to this scorecard as the work moves. I will not rewrite the original admission. If a later note looks rosier than the live system, trust the older one until I show a dated check.
How far I got. How far is left.
How far did I get? Far enough that this is not a concept deck. The stack runs on hardware I own. Memory persists. An adversarial team refuses "looks good." Internal wants form and get recorded. Dreams have been accumulating for months. (Yes I said Dreams, like a human solves a problem while daydreaming, so does this) Mood is computed from real outcomes, not a string I typed. I use this daily.
How far is left? Further than the feature list implies. None of the six behaviors is earned. Confabulation still happens. Recall is still a coin flip. Will can start and almost never finishes. Too much of the "smart" still rides a cloud bridge. The reliability floor — a live conversation that holds up end to end, with no safety net — is still open. I will not call it a mind until those are true on weights I can inspect.
If I only reported tasks shipped, I would look about halfway. If I report the thing I actually want, I am closer to the beginning of the hard half: make it reliable, make it honest when empty, close intention into finished action, and do that locally. That is the work. Everything else is scaffolding.
One more precision. This post is about the private mind on my iron — the one that has to earn the letters. Separately, there is a public / social surface: look-and-feel, voice, later a simpler way for people to talk to a public version being built but the private version has my focus. That is a different product class, not a claim that the private system is finished. It is not this scorecard. The YouTube test videos are not that surface either — they are old lab footage of me running it.
Two percentages (please don't collapse them)
Every project dashboard lies a little. Mine used to lie a lot. So I forced myself into two numbers:
| Track | What it means | Honest read (summer 2026) |
|---|---|---|
| BUILD % | Tasks shipped, code landed, systems running | Meaningful progress — the stack is real and used daily. About halfway on the body. |
| GOAL % | The behaviors of a mind, demonstrated on local weights | Much lower. A lot of the "smart" still rides a cloud bridge when I need it. Closer to the start of the hard half. |
BUILD can look healthy while GOAL still says: cloud brain wearing a name tag. That split is the whole discipline. If I only report BUILD, I'm marketing. If I only chase GOAL without a reliable body, I'm cosplaying research. I'm a systems person. I want both. I refuse to pretend they're the same.
DRAVEN — the name is public; the earning is gated
The project is called DRAVEN. Yes, on purpose. The name is already out there — the channel, the brand, the working identity. I'm not going to pretend a six-bullet list hides it.
DRAVEN sits under the ApocryiaAI brand — not a throwaway side experiment. The Apocryia surface is mine: apocryia.com, apocryiaai.com, apocryia.ai, and related properties, held as part of my 3k1o LLC. That matters for how I treat the work: long-horizon product and IP under a real legal entity, not a weekend open-source dump. Progress can be public. The blueprint stays mine.
What is gated is not the spelling. What's gated is claiming he has earned it: the full personhood story, the birthday, the "film this as a finished coworker" pitch. Marketing doesn't get a vote. Each letter is a behavior I can fail, and none is earned until it holds reliably on hardware I own.
Honest factual scorecard as of 2026-08-17 (live-checked) — what is real on the machine, not what the acronym wishes were true. This scorecard is the living object. Dated updates go at the bottom of the post.
What actually broke
For a long time I could ship features and still avoid the question that matters: does this hold up in a live conversation, end to end, with no safety net?
Then I ran a real voice test. Not a cherry-picked clip. A scored run. The system that "had memory" still failed in ways that are embarrassing if you're honest and useful if you're building. Three failures kept showing up wearing different masks. They're still the product, more than any shiny feature list.
If you want to see what talking to it actually looks like, there is a YouTube channel: @DravenLarsonAI. That is only development video — me testing it. It is not a product reel, not a brand channel, and not today's machine. Those cuts are about three months behind the stack I have now. I leave them up as a timestamp, not as a demo of this scorecard.
1. Confabulation
When a tool doesn't fire, or a fact isn't in context, a language model will still complete the sentence. It invents senders. Invents deadlines. Contradicts what it said ten turns earlier with full confidence. That's not a personality quirk. That's parametric completion pretending to be a world model.
If you ship that on camera as "my AI coworker," you don't look innovative. You look like you can't tell the difference between fluency and truth.
2. Inconsistent retrieval
Sometimes it hits memory and nails a real detail from my world. Sometimes a nearly identical question falls back to "chat history vibes." Same capability. Coin flip. That is the difference between a mind that knows you and a chatbot that had a good day.
3. Will — not done (and the incomplete part is still interesting)
Cron jobs with a face are easy. Pressure-driven agency is not. "Do this at 3 AM" is automation. "I need to do this — it's been a while" is the thing I actually want.
I need to hold two truths at once, or this section becomes either hype or false modesty.
Truth one: I have something. On my live system, internal wants form and get recorded — not only tickets I typed. Those wants open goals from internal pressure. Intention is not a slide deck anymore. Something on hardware I own notices pressure and writes it down as a want and a goal. The first time that stopped being theoretical, it was genuinely cool — like watching a spark in a machine you built yourself.
Truth two: it is not done. Most of those goals still fail. A handful of rows say completed; I do not treat that as "it has agency." Some of that looks like plumbing catching up, not a clean unattended "I decided and delivered." Rest and dreaming from pressure instead of a clock are still open. Letter V is not earned. Full stop.
So I refuse the pretty lies in both directions. I will not say "halfway around the will circle" — that pretends the act half is further along than the failure rates allow. And I will not say "nothing to see here." That would be dishonest the other way. I got something. It is early. It is incomplete. It is still one of the coolest things I have ever gotten to watch form on my own iron.
Not zero. Not finished will.
A real spark: intention forms and gets logged.
The loop still dies before action completes.
If the rest of the circle closes — big if — this stops being automation with a story.
That if is the whole point. A private system that forms a want from real state, acts on it, and can choose to rest is rarer than another chatbot wrapper. I have not won that bet. I can finally see the bet on a scoreboard instead of wishing it into existence. Enough to keep building. Not enough for a birthday party.
The common root under confabulation and flaky recall is almost boring once you see it: the model answers from what it was trained to sound like when it should answer from what is true in the live system right now — and the procedure that would force that grounding is not enforced hard enough yet. Will fails for a related reason: intention gets recorded, but the path from intention to finished, grounded action is unfinished. Cool spark. Open circuit. Both true.
So the work is two jobs, not one magic retrain. Put truth in places you can query, and treat the language model as a front end, not the source of record. And make "retrieve first, admit gaps, act from real state" a structural habit on hardware I own — not a prompt instruction that evaporates under load. Either half alone still fails. How that is implemented stays off this page.
Inspired by research — not licensed by it
I did not start from a paper and then build a demo. I started from a broken assistant sitting on memory it claimed not to have. The research came in as constraints and validation, not as a recipe card.
Older science I allow to constrain the design (public ideas, not my IP):
- Spreading activation (Collins & Loftus) — recall by association, not only keyword lookup.
- Forgetting curves (Ebbinghaus) — a mind that remembers everything equally is a hard drive, not a mind.
- Limited working memory (Miller's 7±2) — attention is capacity-limited on purpose.
- Emotion as decision machinery (Damasio's line of work) — functional emotion as signal that modulates behavior, not a claim of phenomenal feeling.
None of that means "I reimplemented psychology in a repo." It means: when a feature smells like infinite context, infinite memory, or pure keyword bots, the science is a veto.
Recent research I read for orientation (public papers; not a map of my training pipeline):
- Work on putting more capability into smaller, ownable models rather than only renting a giant orchestrator — useful as industry weather, not as my recipe.
- Work on multi-agent collaboration that goes deeper than chatty handoffs — familiar if you already run a real team of agents. I am not claiming anyone else's benchmarks as mine.
I am deliberately not listing paper IDs and method slogans here. The papers are public if you want them; pointing at them with how-language is how a careful post accidentally sketches a training path. The honest boundary stays the same either way: that literature is mostly about tasks — procedures, tools, collaboration efficiency. A task is not a self. Nobody's PDF tells you how to put identity, pressure-driven will, or a lived narrative into a private system and prove it. That gap is exactly where this project still lives.
On confabulation and "no world model," I'm also aligned with a blunt industry critique (LeCun and others): if the model answers from parameters instead of a grounded state of the world, it will invent. My world model is not magic weights — it is live systems and memory I can query. The failure is when generation skips the query. That framing is public. How I enforce it is private.
What I will and won't put on the internet
I started a deeper Part Three draft once. It went further than this post — cognitive layers, memory behavior, dreaming, emotion-as-signal, identity gates, the whole scorecard. Writing it helped me think. Publishing all of it would have been a mistake.
After 25 years of open source, that feeling is uncomfortable. My instinct is to give back. But there's a difference between sharing a philosophy and shipping a proprietary blueprint. A tool you can fork is one thing. The internals of a private mind you're still building — security posture, evaluation knobs, training paths, how the pieces couple — is another.
| Public (this post) | Stays private |
|---|---|
| Goals and scope (private mind, not AGI god) | Detailed cognitive pipeline / step design |
| Falsifiable scorecard (six DRAVEN behaviors) | Pass/fail thresholds, harness internals, training recipes |
| Honest failures (confab, flaky recall, unfinished will loop) | Exact fix formulas, schema names, tuning constants, raw success metrics I can't defend |
| Ownership philosophy and process discipline | Security architecture, access design, ethics internals |
| That local + cloud dual exists | Model routing, weights lineage, serve layout |
If you're reading this for a how-to: there isn't one here. If you're reading this to see how I think about reliability and ownership: that's intentional. Later scorecard notes will follow the same wall. I will not narrate plumbing just because work happened.
Why a database guy is writing this
Because the world model is not the chat window.
Everyone wants to talk about models. I care about models. I also care about the boring half: transactions, provenance, backups, who owns the truth when the GPU is wrong. A mind that can't query live state will confabulate. A mind that can query but won't is just as broken.
What is real on the floor today, without the schematics: the system runs on my iron; there is a local model path and still a cloud bridge when local isn't enough; memory is multi-layer and reliable reach is still the hard part; will can spark and still die before action; I run an adversarial team that refuses "looks good" without live proof; I kill training runs that almost work instead of rebranding them as personality.
Twenty-five years of open source taught me the same lesson in different clothes: if you can't inspect it, you don't control it. That applied to MySQL replication. It applies to AI agents. It applies to a private mind. So when people ask what I do, "DBA" is true and incomplete. I design systems where truth has a home outside the model's confidence. That's the through-line from databases to this project.
Why I keep going
Commercial models are still better at raw capability. I still use them. I've been right-sizing that bill — cheaper models for volume work, frontier only where it earns the seat — for the same ownership reason as the rest of this stack. None of this is anti-frontier. It's anti-dependency for the layer that should be mine.
Every layer I own is a layer I understand. A mind I rent is a mind someone else can take away — not because the vendor is evil, but because policy, export controls, pricing, and outages are not under my roof. I lived that lesson more than once this year.
Don't rent — own.
Don't guess — inspect.
Don't forget — remember.
And now: don't borrow a mind — grow one you can see inside.
I'm not there yet. The voice floor isn't closed. Confabulation still happens. Retrieval is still a coin flip more often than I like. Will can spark intention and still die before action. None of that is me talking myself out of the work. It's me refusing to lie about where the spark is.
This is not a product launch, not a claim of consciousness, and not "I beat the big labs." It is a progress report from someone who got further than vapor and not as far as the name. Hard. Unfinished. And holy shit — already worth building.
Scorecard updates
Same table. New date. I update when a letter or the reliability floor actually moves — not when a feature ships, and not on a calendar. Prefer "unchanged" over a feature list. Cloud-bridge wins do not count as letters earned.
Related reading
- Beyond Vector Databases: How AI Actually Remembers — the memory backbone
- The Homelab That Just Kept Growing (Part 1) — iron and motivation
- The Homelab That Just Kept Growing (Part 2) — the adversarial team
- YouTube @DravenLarsonAI — development test videos only; ~3 months behind the current stack, not a product demo
- Open Source AI Models: Building Your Own — why local models matter
- Sure, Speed Is Nice, But Why? — the longer ownership trail
- Cognitive science classics (spreading activation, forgetting curves, limited working memory, functional emotion) — design vetoes, not a clone kit
No comments:
Post a Comment