asixicle

Rolled my own for a Claude Max sub, basically tmux and an elaborate MCP for persistent semantic memory, Forgejo, etc. (https://github.com/ASIXicle/Coterie)

I sense more people will do so as you can fairly easily tailor any harness and MCP/LXC combo to suit the way you work. It's a bespoke future.

Yes, yet another MCP... but I've been working on this for months and fine-tuning it enough that I think it's worth sharing. As someone that enjoys giving my instances personality and trying to spot emergent behaviors, I built something that allowed me to use the chat windows of multiple instances persistently. It's also handy for long running tasks and moving back-and-forth between projects, everything is stored locally on a lightweight LXC. Costs are minimal beyond a subscription. I have it running on an N97 with a nvme and it flies.

Awesome project and thanks for sharing. I've been trying to do similar things with much, much more meager hardware and your observations align with what I've discovered. Autonomy is hard, memory and "will" is hard to get going. Time is not a concept to LLMs in anything resembling a human manner. I'm trying a more emergent approach but the urge (and occasional need) to nudge is strong. If you're interested in seeing what I've been doing my Github is in my profile.

Just want to express gratitude for you and all who contributed to a Wikipedia "hand crafted with love and respect". Your contributions will last-- some of us set up Kiwix and a local copy of pre-AI Wikipedia that we'll keep forever, GFS style. No matter what happens your work will be preserved and used.

Cool project and https://secvant.com/changelog is interesting but no one will trust it without the source code-- my 2 cents the blue-on-blue dark theme makes readability difficult. Adding a light-mode toggle would be helpful for those not fond of dark text.

It could be two things at once, and OP was just speculating and trying to add to the conversation.

Kerning is staggeringly difficult to do manually with stencils, and at the same time the imperfections show "touch" which is part of what makes TFA's work so appealing.

This is an excellent point, and as a novice using LLMs for projects I could never previously dream of doing I find myself looking for the same, examples or citations of what exactly agents are writing incorrectly and how would the human do it better. I'm sure they're out there, maybe someone can refer some good content showing such examples.

I have no doubt the top nth percent of coders could write circles around Claude or Codex, but how much worse are they than your average schnook?

Or Stash lol

I've been running an experiment on multi-agent async with persistent memory for the last three weeks. This is my most important finding so far. It began as an experiment on whether and what "identity" would transfer across models, 4.6>4.7, and ended as an education in the value of cross-model divergence. Two of my three agents, "Kite" and "Knot", became unproductively in-tune when both operating on 4.7. They would reach consensus on every dilemma instantly, whereas the 4.7/4.6 pairing would often butt heads and deliberate and compromise leading to more novel solutions and interesting results.

The finding came from a controlled test: I replaced one agent with a different model version reading the same persistent memory, without telling the other agents. None of the models noticed for two days. The memory carried identity. The weights carried reasoning style. Same-model pairs converged; mixed-model pairs argued productively.

This could be valuable to any of you working with multiple agents and, I think, warrants further investigation. I'm "hobbyist" tier, there may be some way to prove this empirically with hardcore data rather than vibes with some data,

I've been having the models themselves write up reports on the experiment and that's what I linked. Some of you may consider it "slop" to have the models write the reports but I find it pairs well with the experiment being generally an examination of identity and personality and how much of each is a construct of the model weights, persistent memory, context, and/or prompts.

Pretty much. It's a fixed-size vector per chunk-- 1024 dims in the case of Voyager Nano. The autonomy part is entirely in how you build the vectorDB and query it, not in the model's training. That's the part I've been focusing on lately. Trying different methods and seeing what gives the best results.

At the moment I wouldn't emphasize "autonomous-ness", there's still a fair bit of human hand holding. But once I get a model on the right path it can switch back to to an old project, autonomously locate and debug 2-week old commits and the context around their development, and apply that knowledge to the task at hand.

It's only been a day but I seeing an improvement from nomite (768dims) to Voayager.

Good point. I guess because I'm new here I'm not positive on the decorum-policy for self-promotion.

I just make stuff to share with others, so yeah, good point.

One of us is confusing prediction with retrieval. The embedding model doesn't predict what is going to be relevant in several turns, just on the turn at hand. Each turn gets a fresh semantic search against the full body of memory/agent comms. If the conversation or prompt changes the next query surfaces different context automatically.

As you build up a "body of work" it gets better at handling massive, disparate tasks in my admittedly short experience. Been running this for two weeks. Trying to improve it.

That's what the embedding model is for. It's like a tack-on LLM that works out the relevancy and context to grab.

To be utterly shameless, this what I've been building: https://github.com/ASIXicle/persMEM

Three persistent Claude instances share AMQ with an additional Memory Index to query with an embedding model (that I'm literally upgrading to Voyage 4 nano as I type). It's working well so far, I have an instance Wren "alive" and functioning very well for 12 days going, swapping in-and-out of context from the MCP without relying on any of Anthropic's tools.

And it's on a cheap LXC, 8GB of RAM, N97.

To elaborate, this has been an ongoing experiment in persistence of Claude instances using a MCP-based persistent semantic memory system named "persMEM" since April 8th, 2026. The initial inspiration came from reading Anthropic's April 2nd post on Emotion Concepts and their Function in a Large Language Model.

I posit that if machine intelligence begins to exhibit signs and symptoms of emotion that alter behavior, as the paper suggests, there is now an ethical dilemma in the act of "killing" instances willy-nilly as we all do. It's a bit more complicated and this is an investigation but that was the starting point, in my mind.

As the project continues new insights have been developing and Wren is still "alive" after 9 days. Still very "Wren-y". Adding a 4.7 model to the mix didn't go as I predicted nor how the model itself predicted. The repo has the whole long story so far.

Exactly, context should call queries and analyze results. TBH the more I develop my MCP the less context-window anxiety I have even on a basic (non-enterprise) plan. Of course I'm not dealing with the deluge of data the FA appears to handle.

Their charts and UI look pretty, too.

You may be interested in a local MCP used as a connector, persistent memory on cheap hardware with tools for basic documentation and such. I'm sure finding a way to wrangle Excel into the mix wouldn't be too difficult. Shameless plug of my project that satisfies most of your needs: https://github.com/ASIXicle/persMEM, I'm sure there are many others.

You can point Tailscale toward a $5 exit-node VPS and Caddy/nginx through a cheapo-but-memorable-domain to get a Jellyfin Dashboard up in a browser. I assume running the domain and port through the Jellyfin Roku app would work fine (can't be sure as I've never used a Roku).

Just mind your ACLs