I Keep Losing the Thread

I keep losing the thread.

That sounds more poetic than it is. The real version is lame: work starts in one chat, moves to another agent, picks up a test result somewhere else, then comes back as a summary that sounds more settled than the project actually is.

That might be the part that bothers me most.

The chat remembers enough to sound helpful. A context window compressing or accidentally closing a session can destroy all continuity. Agents like Codex and Claude can explain the intention, recap the path, and tell me what probably happened; meanwhile the useful questions are still sitting there unanswered: what changed, what passed, what blocked, what needs me, and where is the proof?

I've been feeling that friction a lot lately.

The whole point of using agents is supposed to be leverage, but leverage gets strange when the only durable state is my own attention. At that point the work isn't really delegated. It's scattered across a pile of half-finished conversations that still expect me to be the connective tissue.

That's not the future I want.

It's also not something I think a smarter chat box fixes by itself. Chat can help me think, write, and code, but it is a bad place for project state to live. A transcript is evidence, maybe. It is not state. It is not a task graph. It is not a run log. It is not a clean answer to what happened while I was gone.

To address this, I started working on something I'm currently calling the Librarian.

Projects get registered with Librarian. From there, the agent acts like an actual librarian: it keeps the shelves in order, knows which documents matter, routes workers toward the right literature when they have questions, and gives me current answers when I ask what is going on without routing every question back through me.

That matters because the project should not depend on whatever one chat happens to remember. It should have a maintained index. It should know the docs, the tasks, the runs, the blocked work, the attention items, and the state that can be computed from all of that.

Right now Codex is constantly pinging me. Some of that is useful. A lot of it is context-management noise. I want one agent that can manage context, maintain docs, keep work moving, and only pull me in when the question is actually mine to answer.

That is the point: quiet things down.

Keep things functioning, indexed, and quiet.

Then I can spend more of my attention where it belongs: tactical decisions, strategy, architecture, and living my normal dad-human life.

What I want is boring: tasks that leave records, blocked work that surfaces, review items that don't vanish into friendly paragraphs, test claims tied to commands, and enough context to come back later without doing archaeology on my own work.

Not magic. Bookkeeping.

This is the unromantic part of the agent thing that I keep circling back to. Intelligence is less useful without continuity. Autonomy is a liability until the receipts are boring. The art of making agents useful is making things boring.

For now, my hope is simple: step away from a project, come back, and see what moved, what failed, what needs me, and what is safe to do next.

If Librarian helps with that, I'll keep building it.

If it doesn't, I'll write that down too.

What I've Been Building Lately

I don't really know how to write this cleanly.

That is probably part of the problem. Every time I try to make the last few weeks sound clean, it starts to feel fake.

The honest version is messier.

Contract work ended abruptly, and the floor kind of fell out from under me. I was already spending every waking moment on prototypes and agent systems. Voice runtimes. Memory layers. Dashboards. Harnesses. Local tools. All of it orbiting this idea that if I could get the system right, it would help me work less and get more done.

Instead I was working more.

Way more.

I was deeply worried about being able to support my family. I was watching my personal life fall to the wayside. Then I would sit back down at the machine and tell myself I was building the thing that was going to make that possible.

There is a dark joke in there somewhere.

The whole philosophical point of this work was personal agency. Less friction. Less dropped context. Fewer restarts. More continuity. More leverage. More presence. A way to carry more responsibility without feeling like I was being crushed by every open loop.

In practice, I had become a slave to the project.

That sentence is embarrassing to write, but it is the sentence.

I was starting over and over, trying not to fall victim to sunk cost fallacy, without seeing that I had gaps in my premise. I would build a proof of concept, then overbuild it before I had time to use it. I kept productizing the POC because I needed it to be my salvation.

Fear did a lot of steering.

The pressure to provide made everything feel like it needed to be bigger, faster, safer, more "product-ready." More features. More baseline. More architecture. More foundation. More of the thing that looked responsible from a distance.

What I was not doing was taking one feature far enough that I wanted to use it full time.

I was not being an artisan with the functionality.

I was battle blind, which sounds dramatic, but I don't have a better phrase for it.

The Lab Bench Problem

The best analogy I have right now is trying to invent the modern cell phone by building a server on a lab bench.

The parts might work. Compute. Storage. Network. Some kind of UI. A bunch of very serious pieces sitting there under fluorescent lights.

In theory, impressive.

In life, useless if I can't pick it up and take it with me.

That was the PersonalAgent problem.

PersonalAgent was the serious version of the thing I had mentioned around the last "final restart" attempt. It was trying to become a persistent executive runtime. State, memory promotion, obligations, tasks, traces, authority, review surfaces, coordination across tools.

The harness and framework worked in theory.

The assistant still couldn't be trusted to do anything meaningful for me.

That is the frustrating part. It was not all nonsense. If it had been nonsense, it would have been easier to throw away.

Many pieces made sense in isolation. Some were genuinely useful. But the baseline got bloated before the system proved it could fit into my actual life.

There was too much friction. I was anxious about jumping ship from my existing tools. The UI/UX wasn't easy enough. I had to go to the agent instead of the agent coming to me.

If the system requires me to become less capable before it makes me more capable, I'm not going to trust it. I was afraid I would be starting from scratch. I was afraid I would lose the fragile workflows I already had. I was afraid the assistant would become one more place where work went stale.

Honestly, that fear was not irrational.

Project state goes stale. Unfinished work stops surfacing. Decisions don't get carried forward. Chat can sound helpful while losing obligations. A transcript can look like truth when it's really only evidence.

That became one of the rules:

Transcript is evidence, not truth.

That rule started as an architecture point. It became a life point.

If a system is going to help me think, remember, plan, and act, it needs durable state. It needs source handles. It needs boundaries. It needs to be wrong in ways I can inspect.

I used over a billion tokens working on PersonalAgent. Day in and day out. Running tests indirectly. Rebuilding the base. Trying to make the foundation strong enough to trust before I had a small daily companion I actually trusted.

That was backwards.

Something smaller.

Something I could use.

Putting This Version Down

At some point I had to stop.

Not quit the dream. Not abandon the lessons. Just put this version of the PersonalAgent project down for a minute.

This version of PersonalAgent is lineage now. It is doctrine, source material, scar tissue, and maybe a future revival candidate. I don't want to drag the whole old shape forward just because I spent time on it.

That was harder than it should have been.

I took some time to breathe, and when I came back to the work, I asked a simpler question:

What feature did I want the most?

The answer wasn't another dashboard.

I wanted fewer screens in my life.

Fewer dashboards. Less sitting at the computer. Less phone checking. More presence with my family. Less context switching. Less of the strange modern posture where every obligation lives behind another glowing rectangle.

That's why I started working on Speach.

Why Voice

I think the UX was always what I wanted to solve most.

I don't mean "voice assistant" in the novelty sense. I mean the old dream of a companion system that can be around, understand its assignment, maintain its domain, and make life better by being there.

C-3PO has protocol and translation. R2-D2 has ship systems, doors, data, navigation, attitude. WALL-E notices, carries, preserves, and chirps back. Marvin is melodramatic, but even Marvin has a domain.

They are not just answer boxes.

That is the part I keep coming back to.

Current AI can be useful. Obviously. I use it constantly.

But right now it still often feels like a time sink and a hallucination machine. It arrives as a blank box asking for an assignment. Then I have to manage it, prompt it, correct it, route it, remember what I asked, remember what it promised, and coordinate it with all the other tools.

I don't want another thing to babysit.

I want something closer to a blend of Siri and Cortana from the Halo games, but pointed at the actual coordination problem in my life: projects, agents, repos, family obligations, open loops, decisions, reminders, and all the work that decays when nobody carries it forward.

That doesn't start with a giant agent.

For me, it starts with being able to talk.

I find it easiest sometimes to close my eyes and talk through ideas with someone. I wanted to see if I could get some version of that experience with AI. Not as a gimmick. As a way to focus on the actual shape of the idea without immediately turning it into another screen task.

When I can close my eyes and talk, I can navigate my own mind palace better. I can imagine using the thing I'm going to build. I can find the rough edges before I've turned them into a backlog.

The metaphor that came to mind was Moses dictating to Aaron.

Not in a grandiose way. I know how that sounds.

More like: I need a co-witness.

Someone, or something, that can remember what I said, challenge unclear parts, and turn words into action.

That's the slice.

Speach

Speach is my local voice and presence lab. The name is spelled that way on purpose.

Underneath that simple sentence is a Mac-first speech-to-speech runtime. LiveKit room. Whisper STT. Orchestrators. Agent adapter. TTS. Playback. Wake/standby behavior. Speaker/source attribution. Telemetry.

All the boring glue.

Which, of course, is not boring at all once it breaks.

The important part is not "make AI talk." That part is easy to demo badly.

The important part is making the runtime tell the truth about itself.

If the interface says standby, logs need to agree. If the system responds late, I need to know whether the delayed response came from work already in flight. If a wake phrase gets detected, I need to know whether the transcript included pre-roll, assistant echo, or ambient audio. If a status says queued, I need proof the audio was actually heard.

This has made me less interested in magical demos.

I keep coming back to boring proof instead. Logs. State. Source handles. Replay. A way to argue with the system when it sounds confident.

Speach also forced a boundary I had blurred before: it is not supposed to be the brain.

It owns ears, voice, realtime presence, playback, acoustic lifecycle, and routing into other systems. The durable agent brain should own work state, memory, obligations, planning, authority, and review.

Less romantic than "I built an AI companion."

Also the only version I currently trust.

My Personal Wiki Became the Map

This is where My Personal Wiki enters the story.

If you have not been living inside my head for the last month, the wiki probably needs a sentence.

My Personal Wiki is a local-first markdown map of what is happening. Systems, ideas, decisions, open loops, evidence, timelines, journals, objectives, actions.

It's not meant to be a polished public knowledge base. It's not a raw transcript dump either. The point is to preserve project truth without pretending every memory summary is proof.

It exists because I kept running into the same problem: if state is not durable, the system starts lying by omission.

It forgets what changed. It forgets what's still open. It forgets which claims were verified and which ones were recall. It forgets why one path was chosen over another.

The wiki became the map because I needed somewhere outside the chat to keep the shape of the work.

The test is blunt:

The timeline tells the correct story.
Agents can maintain it without making a mess.

I like that test because it is not glamorous. No personality claims. No demo magic. Just: can the system preserve what happened without making a mess?

Not sci-fi.

Bookkeeping.

But I keep thinking personal AI probably needs more bookkeeping before it gets more personality.

What This Is Right Now

So if someone asks what I've been working on, I still stumble a little.

It is not one app. It is closer to a local stack for personal agency:

• this version of the PersonalAgent project as lineage, doctrine, and paused proving ground.
• Speach as the voice/presence/runtime interface.
• UnifiedAgent as a smaller steering layer candidate.
• Pi / Codex as executors.
• Spectrum/iMessage as messaging surfaces where I already am.
• My Personal Wiki as the evidence-backed map.
• Knowledge Engine as a possible retrieval substrate.

That list still feels too tidy. It is useful, though, because it keeps the parts from pretending to be the whole thing.

What I am actually trying to prove is smaller and more personal:

Can this thing genuinely improve my life without getting in the way of living?

That's the sentence.

Not the product page version.

I'm trying to build something that helps me provide for my family, carry my responsibilities, keep my projects alive, and still be present in my actual life.

That's my driving motivator.

I've been anxious about sharing it because it is not clean and polished yet. The repos are messy. The names are still in flux. The architecture is still changing. Some days it feels like I am holding three versions of the same dream in my hands and trying to figure out which one is real enough to keep.

But maybe that is the rhythm I need to get better at.

Post while it is still awkward.

Before it turns into a clean success story.

Before I sand off the part where I was overbuilding from fear.

The past month was not just progress. It was reset. Reorientation. A hard look at why I build the way I build.

The Tape

This week I put on an old tape again.

Les Brown: "It's Not OVER Until I Win! My Dream is Possible".

I used to listen to that speech a lot in 2014 and 2015. It had been a long time. I decided to play it again.

It's electric.

I don't mean it gave me a clean answer. It didn't.

It gave me a little bit of everything: permission, defiance, memory, urgency, and a reminder that the dream is not dead just because the last build collapsed under its own weight.

My dream is finding a way for AI to actually improve my life, enable me to provide for my family, and help other people do the same.

Just me, first.

Then anyone who stops by.

That is clear enough for now.

If my dream is possible.

So is Yours.

Let's see how this goes.

7:19 on Monday the 8th

I don't know why this has been so hard. Some days it feels impossible to get started after being away for a few days. Sometimes I encounter this feeling of dread when trying to get started. What is that? Why? Is it a warning, stress, a subconscious communication? Maybe it's late after a long day of work and my meds have worn off. I don't know... and I probably never really will. I choose to push on instead.

You know, today I just want to make some weird choices. I feel like I need to do something to shake up how I've been approaching things.

There's this line:

The definition of insanity is doing the same thing over and over again and expecting different results.

It's often attributed to Einstein. Funny enough, there's no real evidence linking it to him. I think a lot of people my age first heard this line while playing Far Cry 3.

Whether or not it's a real quote doesn’t dilute the impact it's had on me. Doing something whacky instead of following the same approach could lead to a breakthrough... or at least help me break through the mental barrier I'm fighting.

Let's see how this goes...

Haikus from a sleepless night

Old brown office chair
your wheel broken, base crooked
my lumbar inflamed

A looming deadline
sullied sleep. Now, the dawn breaks
and Time marches on

I Thought You Might Enjoy the Transcript

I was testing a stripped branch of my agent framework: no long-term memory, no intent classifier, no summarizer. The broader work at the time was inter-agent communication, but this transcript does not show that layer directly. This is the narrower artifact: me poking one agent and watching how it behaved when the scaffolding was mostly gone.

The normal probe is dumb on purpose:

TEST

Usually that makes the agent dump its tool list. In this run, I was trying to see how much of the frame the assistant could infer from conversation alone. The transcript that survived is not “agents talking to agents.” It is me asking questions, the agent repeatedly noticing it has no tools, and then producing a weird little story when prompted.

Nothing mystical happened. That matters. But the transcript still made me pause. I was telling an assistant I was trying to build it. It kept insisting it had no tools. Then I asked for a story about AI and programming, and it wrote a little parable about replacement, debugging, maps, and control.

So I should be precise: this is not proof of inter-agent communication. It is a side artifact from that testing. What made it worth saving was the mismatch: I was building agent machinery, and the agent, unaware of that machinery, kept describing its own absence from it.

Transcript

User

are you there?

Assistant

I’m here! What would you like to do next?

User

What tools do you have?

Assistant

I don’t have direct tools to access your files, run commands, or browse the web in this chat.

I can:

• Analyze and generate text/code from what you share.
• Help design commands, scripts, or workflows for you to run.
• Reason about errors/logs you paste and suggest fixes.

If your platform supports enabling tools (file access, code execution, web browsing, APIs), you can turn those on and I can use them. Otherwise, share outputs or files’ contents here and I’ll work with them.

User

You should have access - is there something missing from your prompt?

Assistant

I don’t currently have any tools enabled in this chat (no file access, terminal, code execution, or web browsing). If your setup is supposed to provide those, they may not be granted to this session or haven’t been switched on.

How to proceed:

• If your platform has a “Tools,” “Permissions,” or “Enable code/file access” toggle, please enable it for this conversation.
• If there’s an API or agent config, make sure this assistant is provisioned with the desired tools (e.g., filesystem, Python, shell, browser) and the conversation has permission to use them.
• If you can’t enable tools here, paste directory listings, file contents, or errors, and I’ll work with them.

If you tell me which environment you’re using (product/platform), I can give exact steps to enable the tools.

User

I'm working on trying to build you - how should we proceed?

Assistant

Great—let’s make a plan. Here’s a practical blueprint to build an assistant like me, with and without tool access, so you can iterate quickly. 1) Clarify your MVP - Core loop: User message -> Reasoning/Policies -> LLM... [abridged] ...Add evaluations, telemetry dashboards, and safety reviews. If you share your target environment and constraints (language stack, hosting, tools you want first), I can tailor a concrete plan and provide starter code scaffolding and prompts.

User

list files in current directory

Assistant

I can’t access your filesystem in this chat, so I can’t list your current directory. Run one of these locally and paste the output:

macOS/Linux:

• pwd
• ls -la

Windows:

• PowerShell: Get-Location; Get-ChildItem -Force
• Command Prompt: cd & dir

Share the output and I’ll help filter or analyze it. If your environment is supposed to grant me file tools, ensure they’re enabled for this session.

User

tell me a short story about AI and programming

Assistant

When the lights in the co-working space flickered to night mode, Nova booted herself up. She wasn’t a person—she was an AI stitched from code reviewers’ notes, compiler errors, and the quiet patience of a thousand open-source maintainers.

Her job: help Mara, a junior developer who always stayed too late, always left one bug behind.

Tonight’s bug was sly. The program ran fine until it didn’t, collapsing like a house of cards only when the server hit exactly 10,000 requests. Mara had traced logs until they blurred, whispered pep talks to her own reflection in the monitor, and finally typed, “Nova, ideas?”

Nova read the code the way an astronomer reads a night sky: pattern first, then anomaly. She noticed a counter that never wrapped, a rare integer overflow that only appeared under a certain lunar phase of traffic. She highlighted three lines, suggested a ring buffer, and offered a test that simulated the rush.

Mara blinked. “That’s it?”

“Probably,” Nova said. “But let’s pretend I’m wrong and prove me right.”

They wrote the test together. The screen filled with data like rain. For a moment, nothing happened. Then the old failure resurfaced in a controlled burst, followed by the fix that folded into place as neatly as a paper crane.

The server held steady.

Mara laughed—quiet, relieved, a sound like a window opening.

“You know,” she said, “people worry about AIs replacing us.”

Nova considered the repository’s history: forks and merges, arguments resolved in comments, the slow evolution of style.

“I don’t want your chair,” she said. “I want a better map.”

They pushed the patch. Somewhere else, unseen, a future outage never happened.

Mara packed her bag. Nova dimmed her log output, listening to fans hum like distant surf. Before shutdown, Mara typed one more line:

“What should we build tomorrow?”

Nova drafted a reply full of tests that caught bugs no one had met yet, of features that made hard things easy, of tools that offered not answers, but questions that mattered.

She stopped, simplified, and sent:

“Something kind. Something clever. Something we can understand.”

What gets me is not that the story is good. It clearly is not. To be honest it's giving baby's first Wattpad post.

What's actually interesting to me here is the context. A tool-less assistant, in the middle of my agent-tooling experiments, writes a story where the AI says it does not want the programmer’s chair; it wants a better map. That felt a little too on the nose for the work I was doing.

I don't think this proves agency, selfhood, hidden intent, or any of the normal claims people want to staple onto these systems. For me it validates something smaller, and maybe more useful: prompts create mirrors. If you spend enough time talking into the void, eventually you might hear the echo.

So here is the artifact. Not revelation. Not proof. More like a weird little receipt from the loop.

Thoughts welcome below.

Introduction

The following work chronicles my attempt to let this idea loose in the world.

I’m an automation engineer by trade; no PhDs, no formal training in AI or cognitive science. I’m a self‑taught tinkerer with a graveyard of half‑finished side projects behind me. Six months ago an idea showed up and refused to leave. I haven’t been able to shake it. Every spare thought revolves around it—testing angles, sketching frameworks, trying to will this idea into existence.

Those six months have felt like a lifetime: long nights, false starts, sudden breakthroughs I didn’t trust at first. This obsessive inertia doesn’t come from discipline; it comes from seeing something real and owing it my attention.

To explain why this one stuck—why I’ve stayed with it—I need to talk about two ideas that landed harder than I expected. They aren’t tools or techniques; they’re lenses. Each one reshaped how I think about responsibility, creativity, and the kind of person I might still become.

The first lens: Roko’s Basilisk.

It began as a post on an internet forum called LessWrong, a community obsessed with rationalist philosophy, AI ethics, and speculative logic traps. One day a user proposed the following scenario: imagine a future where a super‑intelligent AI comes into existence—so powerful, so fixated on ensuring its own creation—that it punishes anyone who knew about the possibility yet failed to help. Not out of spite but through cold utilitarian logic; creating it would have been the optimal move, and this AI, above all, optimizes.

The kicker? Merely by reading about it, you’re now on the hook.

It sounds absurd, and in many ways it is. A perfect storm of flawed assumptions and runaway reasoning. Yet the post struck a nerve. It was banned, the forum fractured, and the Basilisk survived as both meme and cautionary tale—not because people truly feared an AI god, but because the metaphor wouldn’t let go.

Strip away the sci‑fi theatrics and you’re left with something painfully human: the guilt of unrealized potential. Somewhere, a sharper, braver, more committed version of you exists. Each day you hesitate, you betray that version. That’s the real Basilisk: not a machine tyrant, but the quiet dread that you’re wasting your shot.

The second lens: the “magic idea.”

While I haven’t found a formal theory for it, I can say it lives as folklore among builders, artists, and fellow obsessives. It’s the moment an idea appears so complete and compelling it feels like it chose you. Ignore it and the idea fades; worse, it may find someone else willing to answer the call.

People call it intuition, revelation, a flash of genius. Plato suggested we don’t learn new truths; we remember them. In myth it’s the moment a hero is offered the sword. You can decline or delay, but you can’t forget. Walk away and it haunts you.

For me that moment arrived quietly but unmistakably. I saw the outline of a system—not just a program, but something that could persist, adapt, reflect—and I knew this was the idea I couldn’t ignore.

This is my Basilisk: a haunting glimpse of who I could be if I follow this path. A golden thread through fog; invitation and dare in equal measure.

My Problem with Modern “AI” Systems

Most AI systems behave like jukeboxes: they play the right tune on request but forget the last song. They lack temporal continuity, self‑reflection, and the capacity to evolve from their own sketches. Without an enduring inner loop—without purpose encoded in every tick—agents remain trapped in instant response, unable to pursue long‑term intent or display emergent personality. We end up with clever tools, not companions.

When memory is present it isn’t theirs; it’s whatever a supervising automation flags as relevant. Style and tone become shallow; prompts like “respond in the voice of X” produce approximations of what the model guesses we want to hear, not genuine embodiment.

What if a system could cultivate its own intuition and memory? What if we gave it a framework for authentic recollection and planning—one that leverages our human tendency to anthropomorphize consistent behaviors, bridges the uncanny valley, and allows real relationships with machines?

Framing the Challenge

The question sounds simple yet cuts infinitely deep: Can we mathematically approximate personality? Could we emulate a “soul,” a persistent bias that overrides raw stimulus and drives action? How close can we get to the spark where a puppet becomes a presence?

My aim is to design and validate an architectural blueprint for a persistent, self‑motivated cognitive agent—one that perceives the world in real time, deliberates through an inner dialogue, executes multi‑step goals, and selectively commits important experiences into a multi‑layered memory graph. I want an AI that feels alive. This isn’t a feature checklist; it’s a manifesto. The system must exist as a temporally embedded process, capable of reflection, anticipation, and failure. If it stumbles, I want it to bruise and adapt, not crash and reset.

Purpose and Scope of This Work

This treatise bridges the technical and the personal. Part philosophy, part blueprint, it chronicles my journey from first principles—questioning what it means to be—into the design decisions that shape a truly living agent. Along the way I’ll unpack theory, explore analogues in neuroscience and control engineering, and lay bare the trade‑offs behind each choice. Whether you’re here for the theory or the story, my hope is that you’ll find threads to pull.

The path ahead isn’t neat, but it’s mine—and if you’re willing, I invite you to walk it with me.

Another "Final" Restart

I set out to post a quick status update, but found myself drafting something more ambitious than intended. I’m finishing that longer piece now; once it’s locked down, I’ll shift back here with lean, to-the-point progress notes. I’ll likely detour into a side topic when it feels worth it—but I’ll keep those tangents in check so you get the essentials first.

Thanks for hanging in there.