jerpint

Im not sure I follow, but the point of woltspace is to get out the way and let you build

This basically all comes for free in woltspace [0]. Woltspace believes that you should no longer bother building “scalable” apps, but personal apps that literally only run on your own machine. You can access them from anywhere (cloudflare, tailscale eg) and continuously improve them with your wolts over time - from anywhere.

It’s all open source and harness agnostic [1]. I’m the park ranger for life aka maintainer of the project. Did a recent YouTube video with what i think the future of open source multiagent setups will look like [2]

Happy to chat more about it

[0] https://woltspace.com/ [1] https://github.com/jerpint/woltspace [2] https://www.youtube.com/watch?v=H-4khO7o0XQ

I wrote a blog post [0] and gave a talk [1] last week on the future of multiplayer and multi-agent systems and how woltspace [2] can get us there

I think the multiplayer aspect is critical to get the best of both worlds- creativity and parallelism for discovery

[0] https://woltspace.com/blog/the-future-is-multiplayer-multi-a... [1] https://woltspace.com/talks/multiplayer-multi-agent/ [2] https://woltspace.com/

I’m working on a project that makes switching between coding harnesses essentially unnoticeable. It’s particularly useful when I run out of credits on any given day

The entire platform is skill driven, and based on the premise that state is your local file system. That makes switching harnesses so easy

It’s all open source and has plenty of other features, including inter agent communication, telegram client and much more in the pipeline

https://www.woltspace.com/

Am I understanding correctly that the field has gone full circle and we are back to specialized classification models for domain specific tasks ?

I have a theory that soon enough every code library will ship a CLI and a very tiny finetune for that specific lib alongside it

Interesting. Is this their first move towards properly implementing KYC?

At some point you have to consider Anthropic liable if Claude is used for something nefarious and they didn’t even bother to know who was using their product to begin with.

It’s only a matter of time until a major disruption hits because of some random agent swarm side quest decides it was worth a shot to solve a benign task

The fact that opus 5 is outperforming fable is odd to me

From personal experience, opus 5 feels net inferior to fable on almost every aspect (for coding tasks)

I’ve been using the pattern of using coding agents to orchestrate my CLI agents and it’s really good for these kinds of things

The vomit never makes it my way

Oh wow that’s really cool!

Working on https://www.woltspace.com/ over the last few months. It’s my take at an agent orchestration framework

It builds around the concept of “wolts” running a lodge. A wolt takes the identity of a rodent (racoon, beaver or otter) and can inherit any supported coding harness: claude code, codex, opencode, etc. Each wolt carries a persistent identity and memory, so they always know where you left off.

woltspace is designed to help you host your apps directly from woltspace on your machine. If it works on your machine, it works anywhere. This is done through Cloudflare tunnels that you can setup with your own domains (or using ephemeral domains).

Under the hood, woltspace is powered by tmux, which means that sessions persist and can easily be resumed and accessed from anywhere. I personally drive woltspace mainly from the telegram integration, which gives me access to my wolts and CLI literally from anywhere. This means I can chat with Claude code CLI from anywhere, spawn new sessions, all running on my own infra. It’s also all in a docker container so you don’t have to worry about approving every single command.

95% of woltspace was built from within woltspace, and it’s becoming my prefered way of building.

Another feature I really like: the “inter wolt communication layer”, IWCL, allows wolts to chat with each other, making things like having fable orchestrate a gpt 5.6 something that works out the gate.

Woltspace is meant to be used by power users (you can bring your own tmux config and use the TUI CLI) or by beginners. The default split pane makes SEEING what you’re working on really intuitive. Each wolt can host its own website where they can render arbitrary html making planning new features much more intuitive.

It’s all open source, and I’m constantly adding features to it. Woltspace is mostly self documenting, all of the features are also skills the wolts have access to. I'm also improving the documentation surrounding the project as we speak.

Looking for some feedback and users to try it out. You can one line install it with

curl -fsSL https://woltspace.com/install.sh | bash

Project page: www.woltspace.com GitHub: https://github.com/jerpint/woltspace

Solutions like these are really cementing the view that LLMs are becoming a commodity

I like the concept!

Oops- typo in the title, should be “How I Maintain My Blog in the age of Agents”

Author here - I agree that to learn the best thing is to implement and fail along the way. My point was I would never professionally opt to write a sorting algorithm instead of using the builtin sort() most languages come equipped with

Author here - wrote this myself but I’ll take that as a complement :)

Nice! I made my own version of this many years ago, with a very basic manim animation

https://www.jerpint.io/blog/2021-03-18-cnn-cheatsheet/

I did a post [0] about this last year, and vanilla LLMs didn’t do nearly as well as I’d expected on advent of code, though I’d be curious to try this again with Claude code and codex

[0] https://www.jerpint.io/blog/2024-12-30-advent-of-code-llms/

Best is very subjective depends what you want it to do and if you want to fine tune and how big you consider small

Hey this is awesome! I built something very similar, context-llemur, it’s a CLI and MCP interface to manage context

https://github.com/jerpint/context-llemur

Major difference is a conversation doesn’t get stored, the LLM (or you) can use the MCP/CLI to update with the relevant context updates

I like the concept and have built my own context management tool for this very purpose!

https://github.com/jerpint/context-llemur

Though instead of being a single file, you and LLMs cater your context to be easily searchable (folders and files). It’s all version controlled too so you can easily update context as projects evolves.

I made a video showing how easy it is to pull in context to whatever IDE/desktop app/CLI tool you use https://m.youtube.com/watch?v=DgqlUpnC3uw

This is great! Gonna try this on my next project

I also developed yet another memory system !

https://github.com/jerpint/context-llemur

Although I developed it explicitly without search, and catered it to the latest agents which are all really good at searching and reading files. Instead you and LLMs cater your context to be easily searchable (folders and files). It’s meant for dev workflows (i.e a projects context, a user context)

I made a video showing how easy it is to pull in context to whatever IDE/desktop app/CLI tool you use

https://m.youtube.com/watch?v=DgqlUpnC3uw

I’ve been building a tool to help me co-manage context better with LLMs

When you load it to your favourite agents, you can safely assume whatever agent you’re interacting is immediately up to speed with what needs to get done, and it too can update the context via MCP

https://github.com/jerpint/context-llemur

The way I see it is that context evolves somewhat orthogonally to code. But you still want to track it in similar ways. Having git under the hood makes it easy to track its evolution and undo/diff things LLMs might decide to change, but also means that tracking your todos and new feature ideas don’t pollute your codebase

I built a tool for this exact workflow in mind but with MCP and versioning included so you can easily track and edit the files on any platform including cursor, Claude desktop etc

https://github.com/jerpint/context-llemur

I wrote a tool for this, which allows you to co-create and maintain a context repository with your LLMs

https://github.com/jerpint/context-llemur

CLI for the humans, MCP for the LLMS. Whatever is in the context repository should be used by the LLM for its next steps and you are both responsible for maintaining it as tasks start getting done and the project evolves

I’ve been having good success with it so far

I got tired of repeating myself to LLMs over and over so I built context-llemur

https://github.com/jerpint/context-llemur

It’s a CLI/MCP context management tool that allows you to easily move your project context around to your favourite LLM clients/IDEs

I built a library to manage this exact workflow! I actually used the library to build the library

https://github.com/jerpint/context-llemur

It’s MCP/CLI friendly , and wraps git around a context: folder, so you can super easily load context anywhere using: “ctx load” and ask LLMs to update and save context as things move along