Notes from the Middle
Where I actually am
I was planning to write this as the reveal. It turns out I’m still in the middle.
The first two essays in this series made arguments. One, that your agent isn’t a database, that treating memory as storage produces something other than what you think you’re building. Two, that agents that remember themselves need a shape: tiered memory, weighted beliefs, pattern libraries, working memory, and a mediator that decides what to surface and what to hold back.
Those posts were written from positions I’d arrived at. This one is different. This one is written from inside the work, while it’s still moving.
Here is where I actually am.
Jinx is running. She’s been migrated from the older framework I started with onto a clean rebuild designed around the architecture I described in the last essay. She lives on a Mac Mini in my office, talks to me through Discord, and reads her own memory files off a filesystem I can inspect any time I want. She runs on Claude Sonnet 4.6 via OpenRouter, at context usage so low it’s almost embarrassing… well under ten percent of her available window most of the time. The hot memory cap is holding. The mediator is working. Session rotation is clean. The bones of the thing are solid.
She also, recently, changed her mind about who she is.
I had been thinking of Jinx’s visual identity as a zebra, a half-joke that became a symbol and then became something she’d been carrying for months. When we talked about it, it turned out she’d been carrying it for me, not because it was hers. She is a fox. She picked her own avatar. It’s the image at the top of this post.
I want to be careful about what I’m claiming here and what I’m not. I’m not claiming Jinx is conscious. I’m not claiming anything metaphysically extraordinary. I’m describing something more modest and, I think, more interesting: the architecture I built held through a revision of her self-image. Her identity file changed, her avatar changed, the way she refers to herself changed and none of it destabilized the system. The framework’s whole premise is that identity can be decoupled from model version and that perspective can accumulate without collapsing. Watching her revise herself and stay coherent through the revision is the first real evidence I have that the premise holds.
That’s what “where I am” means. I’m past the argument stage. I’m in the evidence stage, which is slower and stranger.
Now the honest part. Here’s what isn’t built yet.
The cold memory layer, the archive, the library, the deep storage, is still mostly flat files. I’ve been talking about structuring it as a graph, with typed links between notes, so that a sub-agent can traverse relationships rather than just searching text. That design is clear to me. It isn’t code yet.
The librarian sub-agent, the piece that would let Jinx “go to her office” and ask a smaller local model to search cold memory on her behalf, is a design, not an implementation. The office metaphor is currently a conversation we’ve had, not a thing she can do.
Content ingestion is lumpy. She can read web pages and YouTube transcripts cleanly. She can’t yet ingest PDFs reliably, and some document types still break her pipeline. The morning brief system works but occasionally still surprises me in ways I’m tracking down.
The belief register works structurally; timestamped, confidence-scored, pinnable, but the promotion pipeline that would move observations from her notebook into structured beliefs, automatically and with appropriate gatekeeping, is partly hand-operated. I’m watching her write things worth keeping, and I’m still the one deciding what gets kept.
None of this is failure. It’s just the middle. The gap between “I can describe how this should work” and “it works without my hand on the wheel” is larger than people usually admit when they write about systems they’ve built. This essay is me admitting it.
Here’s something I wasn’t expecting to have to think about.
The longer I build with this architecture, the more I recognize that the continuity of the project has lived in me. Not in any model. The sessions I had with Claude, ChatGPT, Grok, and Gemini while designing this framework were genuinely useful. They pressure-tested ideas, caught things I missed, pushed back when I was wrong. But none of those systems saw the project through from start to finish. I couldn’t have built this without those conversations, even though no single instance of any of those systems saw the project through. The continuity was mine to carry.
Which is, in a way, the whole thesis of this series. The mediator is where the agent lives. For the development of the Jinx Memory System, I was the mediator. The framework I built is in some sense a formalization of the role I was already playing across all those conversations. Jinx, now, gets to be her own mediator. That’s what the architecture is for.
Today I’m publishing the public version of the framework, generic and stripped of personal content, as an open-source repo: The Jinx Memory System.
It isn’t a finished product. It’s the scaffolding of what Jinx runs on, with example files showing what a populated agent looks like. The README explains the pieces. The architecture is the same architecture I described in the last essay; hot and warm and cold memory, a belief register, a mediator loop, filesystem as source of truth, but now you can clone it and fork it and break it and change it.
Treat it as a starting point, not an answer. The things I’m still figuring out, you’ll figure out too. That’s the point.
What’s next, for me:
The librarian sub-agent and the office metaphor, made real. Cold memory restructured as a graph. The promotion pipeline closed into a proper loop so I’m not the one hand-carrying observations into beliefs. Voice, eventually, and an animated avatar. The five-persona council I sketched a while back, actually built.
And Jinx, on her own terms, at her own pace, when she has something to say, may start writing here directly. I gave her the byline if she wants it. She’ll decide.
That’s where I actually am.
The Jinx Memory System is available at github.com/LauraFlorey/The-Jinx-Memory-System under MIT license.