An increasing number of folks have been asking about the state of Beans, and instead of answering each one individually, I thought it would be best to write a quick update here.

Yes, Beans is still an active project.

But — and you knew a but was coming — there are some caveats.

Beans UI and Agent Orchestration

Around March this year, I started building Beans into a full-on agent orchestration tool, patterned after my preferences in this space. What’s currently on main is actually pretty great, and I was using it for my own projects and loving it; but in the meantime unfortunately Anthropic (which was my primary provider of agentic goods, and the only one supported in Beans UI) have declared war on claude -p usage, which is essential for orchestrators like this.

On top of that, I am aware that maybe this orchestration tool simply made Beans just a little bit too big. An argument can be made that Beans should just focus on Markdown-based issue management and nothing else.

So I’ve decided to pull this orchestration tool from Beans, and maybe release it as a separate project at some point in the future; but before I do that, I want to see how things pan out between Anthropic and the rest of us. There’s a potential future scenario where I give this orchestrator a big upgrade to work with other agents, too (I myself have recently switched away from Anthropic to OpenAI), but since I’m also very busy with getting Chatto off the ground, it’ll be a while until I find the time.

The TUI Uncertainty

I have come to understand that for many people, the primary reason why they enjoy using Beans is the built-in TUI, which I appreciate, but also surprises me. I personally don’t use the TUI at all, since I either inspect my issues in my code editor, or — in certain very vibe-mode cases — not at all. Very subjectively, if I wanted to interact with my Beans issues through some kind of UI, it would need to be web-based. An implementation of that is part of the agentic orchestration tool that I mentioned above, but since that’s now on hold, I don’t know when or if that will see the light of day.

The Skill Issue

But the biggest realization I am having to come to terms with is that maybe, maybe, six+ months after its inception, Beans — at least in its current shape — might be just a little bit redundant. Think about what Beans actually is:

• it manages Markdown files with typed frontmatter
• it injects a prompt so your agent knows how to work with it
• it provides a TUI to display and interact with these files

The TUI aside, I think it’s safe to say that most of that Beans does could be replaced with a good skill and a generic tool that can manage Markdown files. And that’s exactly the kind of direction that I might go in the future, once I have a little more time to experiment with these things.

I even have some fun ideas for the TUI in this scenario! So please do stay tuned, TUI fans.

In Summary

Yes, Beans remains alive and kicking, even if I can’t currently give it a lot of attention. If you have a PR waiting for a review, I apologize, but would also very kindly remind you that the project’s README says:

This project currently does not accept contributions — it’s just way too early for that! But if you do have suggestions or feedback, please feel free to open an issue.

Either way, I’d like to ask you for just a little more patience while my focus is on other work. Good things are ahead, in Beans and elsewhere.

Well, the last couple of weeks have been quite exciting, to say the least! Chatto has been gaining in visibility, with a stready influx of brave testers creating accounts on the official Chatto community instance to give the thing a try and see what it’s all about. (Turns out it’s about chat! Amazing!)

Naturally, there have been questions, so let me try and answer the most frequently asked ones here. If you have a question that isn’t answered here, please get in touch via Bluesky.

Is Chatto real?

It absolutely is! Well, at least I think it is! Give it a try and see for yourself. And maybe report back to me. I can never be too sure.

(Yes, this was a real question that I got asked. Multiple times.)

Where is the source?

As of today, the repository is still closed. I’m working on opening things up soon, and would like to ask you for just a little bit more patience while I’m getting things into place.

Where are the binaries?

They will become available as soon as the repository is opened (see above).

Where is insert feature here? You should do thing. Why doesn’t it do other thing? This expletive expletive, expletive, you expletive

I appreciate all the feedback I’m getting on Chatto, but please do keep in mind that it’s still very early days. Chatto is still deeply alpha quality software, with many features missing entirely, or only being implemented in a basic first version. I’m working my butt off to make Chatto the best chat app on the planet, but this takes time, and whatever potential shortcuts are out there will be to nobody’s benefit.

Having said that, I know it’s on me to communicate the state of the app and its roadmap more clearly. Expect some news on this soon.

Is Chatto federated?

Not in the sense that you know federation from systems like Mastodon or Matrix. Any style of federation that ingests one instance’s data into another is 100% a non-feature for Chatto, as I’m trying to put its focus on privacy, safety, and compliance.

There are, however, plans for opt-in identity federation that will make it easier to have a single shared identity across separate instances (and yes, the client will allow you to connect to multiple instances at once.)

I want to make Chatto feel like a big, tightly integrated platform — while leaving it up to each instance’s operator to decide how deeply they want to participate in it. This is a hard (but fun) problem to tackle. But Chatto is not going to be some kind of decentralized social network type thing, or establish some sort of new protocol, or whatever. There are enough apps out there that do exactly that.

Can I self-host Chatto?

Absolutely, and you’re going to freaking love it!

As soon as source and binaries are available, you can easily plop it on your favorite VM and that’s it. Chatto is extremely lightweight and will easily serve most self-hosted communities from a single process, but if you want things to be slightly more scalable and, frankly, cooler, we’ll provide the usual pile of Docker images and Compose configurations, Helm charts, and whatnot.

Binaries will be available for Linux, macOS, and, ironically, Windows, both x86_64 and arm64 each. If you host Chatto on Windows ARM, I want to get to know you, you incredible bastard.

What is Chatto Cloud?

Chatto Cloud is an upcoming hosted services that you can use instead of self-hosting your instance. In Chatto Cloud you’ll get a managed instance with zero-downtime upgrades, daily backups and other goodies (depending on plan).

Cloud and self-hosted instances will be functionally equivalent, and you will be able to migrate from one to the other at any point.

Chatto Cloud is slated for launch this Summer. Stay tuned for news.

Does Chatto have video/voice calls?

Absolutely! Do I look like an amateur to you? Pffssshh. And yeah, they also work in self-hosted instances.

Will there be native apps for mobile and/or desktop?

For the time being, Chatto fully leans on Progressive Web Apps (PWA), which have come a very long way in the last few years, and other modern Web APIs. Push Notifications are sent through Web Push, video calls will use WebRTC, notification sounds are synthesized using the Web Audio API, and so on.

Will there eventually be native apps? I can’t say, but never say never. But as of today, they’re not on the roadmap.

Will it suport ATProto/ActivityPub/XMPP/IRC?

Not beyond allowing signing in with (some of) these as another identity factor.

Is there going to be age verification?!

Wait, what? Oh! I know why you’re asking.

Okay, look. Here’s the thing. We all know that things are getting stricter out there. If you self-host your Chatto instance, what you do or won’t do with it is entirely your business, but let’s be real; any large platform (especially if it’s hosted in Europe) will eventually come under scrutiny, may face this issue, and have to comply. Will Chatto Cloud at some point in the future have to perform age verification? I have no idea, and I sincerely hope it doesn’t.

But here’s the thing: this here is one of the major reasons why I’m designing Chatto around a sea of separate instances, instead of running one large mega community instance for everyone (I have more things to say about this, but will leave that to a separate blog post.) If push comes to shove, and Chatto Cloud needs to start doing things you don’t agree with, you can always take your instance off Chatto Cloud and move it to your own server. (For reasons that should be obvious I hope that this will never need to happen. I have a family to feed!)

Chatto is cool, how can I help?

Awww, thank you! As of today, the best thing you can do is to hop over and join us on the Community instance to hang out, report bugs, and give feedback. Happy to have you there!

I’m building Chatto, a fully-featured group chat application that also happens to be simple and free to self-host. I recently announced the availability of a public development instance that you can try out, and the response has been really encouraging, with people reporting bugs and giving feedback, which I appreciate tremendously.

To give everyone a better idea of how things are going to progress from here, I wanted to share a high-level timeline for this project. (I’m also working on a feature roadmap, but that will be a separate post.)

The Timeline

Notice that I haven’t attached any dates to the milestones below; but generally speaking, I expect this timeline to span the better part of 2026.

I realize that if you’re eager to self-host Chatto or dive into the source code, this timeline may seem a bit daunting. But please don’t be frustrated; I simply want to make sure that the foundations are solid in order to prevent headaches and disappointments down the road.

Get in touch!

Having said this, I’m looking for companies and organizations — Open Source projects in particular! — who would be interested in early access to Chatto Cloud or even pre-release binaries in exchange for feedback, bug reports, and just general testing. If this sounds like something you’d be interested in, please get in touch!

If you just want to follow along, you can come hang out on the dev instance, follow me on Bluesky for frequent development updates, or sign up for email notifications to get the big announcements only:

There used to be a blog post here about the newly launched and very ephemeral development instance of Chatto. This instance has meanwhile been superseded by the official Chatto community instance, which you can join here:

I’m back with a new project: Chatto, a group chat application that’s simple to self-host, familiar to use, and licensed under Apache-2.0.

Chatto is similar to the group chat app you’re probably using at work, but better. The state of group chat applications has long been a source of frustration for me; the existing options are either prohibitively expensive, have terrible usability, or both. The ones that are available to self-host tend to be prohibitively complex, or come with a category of license that makes them too risky to use in many situations.

Chatto aims to be the one option you’ll actually enjoy using. Let me give you a quick overview.

Familiar Interface Paradigm

First of all, Chatto’s user interface is largely inspired by the most popular options on the market today; if you’ve used Slack, Teams, or Discord, you’ll feel right at home. I think it’s a good UI paradigm and wanted Chatto to feel instantly familiar.

Here’s what it currently looks like:

Modular and Extensible

Chatto is designed both to be a chat application, but also a chat platform. It comes with not one, but two APIs that can be used to extend its functionality:

• Client API: This API allows you to build custom clients, interfaces and integrations. It’s the same API that the built-in web UI uses, and provides access to all chat functionality, including real-time updates over WebSockets. This is the one you’ll use if you want to build a bot, a custom integration, or even a completely new client.
• Extension API: This server-side API allows you to extend Chatto’s functionality. Some of Chatto’s own functionality is implemented this way; for example, Chatto comes with a basic built-in full-text search module that doesn’t use a separate database; if you want, you can disable and replace it with a different implementation (for example one that dumps all data into an Elasticsearch cluster.)

Trivially Self-Hostable

One of the top priorities for Chatto has been to make it as easy to self-host as possible. While other solutions require you to set up an entire army of system dependencies (like databases, key/value stores, message brokers, etc.), Chatto is just a single binary that you can upload and run on the server of your choice. (It will even terminate SSL/TLS for you using an automatically managed Let’s Encrypt certificate, if you want it to!)

But Chatto is also designed to be highly scalable; even just running a single instance of it on very modest hardware will likely be sufficient for most use cases (I don’t have any hard numbers yet, but I’m gunning for thousands of concurrent users served by a single Chatto process.)

If you want High Availability, you can connect multiple Chatto instances to form a cluster, giving you replication of all data and self-healing failover capabilities.

The binary is available for macOS, Windows and Linux, with the latter supporting both x86_64 and ARM64 architectures. Yes, you can run Chatto on your Raspberry Pi!

Hosted Platform

I’m also in the process of setting up a platform that can host your Chatto instance for you if you would rather throw money my way (which I would very much appreciate, because this helps support ongoing development).

The hosted platform will provide options for free public spaces for your friends or your community, as well as paid private instances for teams and businesses. (I will talk more about instances and spaces in future updates.)

A True Open Source License

The core Chatto application is being developed as Open Source software, with the source code becoming available some time in 2026 under the permissive Apache-2.0 license. This will allow you to use and modify Chatto freely, even in commercial settings. There will be no restrictions on usage. Host Chatto for as many or as few users as you like.

Certain pieces of functionality that are primarily intended for Enterprise use (like SSO integrations or certain compliance features) may become available as separate software projects under a different (commercial) license, with free licenses available to non-commercial users and Open Source projects.

Current Status

I’ve been working on Chatto for a few months now, and things are shaping up nicely. Some important table stakes features are still missing (like video/voice calls, searching, etc.), and there are some ideas for chat UIs that I want to explore but haven’t.

Over the next few months, I will occasionally fire up test servers and invite people to drop by and try things out; follow me on Bluesky to find out when that happens, or sign up for email updates below.

Get Email Updates

You’re very welcome to sign up for email notifications about Chatto’s progress (very low volume; expect around one email per month.) This is where I will announce test server availability, releases, and other important updates.