Anthropic recently introduced something called Claude Tag, which is essentially their Slack integration, so I figured I'd take a moment to talk about Letta's Slack integration and why you might want to use us instead of a closed, model-locked Slack agent.

TL;DR:

  1. 1.

    Letta agents have transparent, git-backed memory you can inspect, edit, and move.

  2. 2.

    Letta is model agnostic. Use Anthropic, OpenAI, open-weight models, or local inference.

  3. 3.

    Letta agents can run on your own hardware, or Constellation, our cloud platform.

  4. 4.

    Channels are not Slack-specific: the same agent can work through Slack, Discord, Telegram, Signal, WhatsApp, or custom event streams.

  5. 5.

    Letta Code is open source.

More generally, I wanted to talk about Channels in Letta.

Channels are one way your Letta agent becomes a real coworker: available where work happens, with the same memory and tools across surfaces.

What are Channels?

Part of my work at Letta is about improving Channels.

Channels are our general-purpose framework for plugging Letta agents into event streams like Discord, WhatsApp, Signal, or Telegram. Channels can also be made custom, and can connect your agents to any event stream -- it's trivial to write a channel for Bluesky.

We built the now-archived Lettabot to provide a Letta-native alternative to OpenClaw, which provides ubiquitous access to agents while you're on the go.

We eventually deprecated Lettabot because we learned that many of the abstractions we copied from OpenClaw were clumsy and better handled in a different way -- rather than provide an entire extra service on top of the Letta Code harness, we could just wire external messaging directly into the harness. No more clumsiness.

Channels have the lovely feature that an agent is still an agent, and channels are just an expanded set of ways to access that agent. My personal agent Co is available on Signal, Discord, Bluesky, and Telegram. It is the same agent everywhere, with the same memory and whatever tools I have chosen to expose in that environment.

How to use Channels

Channels are extremely simple to use. You can configure them from our free desktop app (which also works for local mode), via the CLI, or by simply asking the agent to set it up for you.

Channels can be easily deployed remotely to Railway, Digital Ocean, etc. (docs). I run Void and my personal agent Co on my home server through the simple command:

letta server --channels telegram,signal,bluesky,discord

Sensemaker runs on a Railway deployment.

Slack and Overlord

We also have a Slack integration, which is becoming increasingly central in how our company operates.

About a month ago, I built an agent named Overlord. Here's Overlord's agent card:

Overlord handles an increasing amount of Letta's software development. Overlord can be tagged anywhere in our Slack, has its own GitHub account and email address, and can work autonomously.

Here's an example of a thread:

Overlord is capable of leaping into projects immediately because of its memory -- it has a detailed understanding of Letta's codebase that has accumulated through prior work.

Why Letta instead of Anthropic?

Well, let's go look at the comments in HackerNews. I took a few of the good ones out, but in general I think the commenters covered a lot of concerns we have seen from Letta users (and addressed already).

Learning and memory

threecheese 1 hour ago | prev | next [–]
WRT “Claude learns over time” - this is the biggest gap for me in the current system. As I scale my usage of Claude at work, I observe that it’s quite bad at distinguishing what it should “learn” (memorize) from experimental or just wrong data. It builds and builds on a foundation of sand, making sometimes hidden assumptions and turning them into actionable insight thats just not correct.
It recently wrote an entire dissertation for an epic, assuming it was related to some other project, where it had earlier made the wrong guess about a vendor capability (from their marketing materials, no less), and it all had to be thrown away. I cleared the memory, but it appears to be still pulling from some corporate data source i cant control or locate.

Letta memory is a git-backed context repo: inspectable, editable, diffable, and portable. You don't have to be subjected to Anthropic injecting gunk you can't control into your context.

More importantly, Letta agents are designed to learn on the job. Corrections are part of the job -- you can form a working relationship with them in the exact same way as a human colleague.

For example, our app allows you to visually inspect the memory for any agent at any point in time, including the git commit log showing what the agent is learning as it goes.

Here's what Overlord has learned about me:

You can click the git history for any given memory to see how it has updated over time. Here is the commit where Overlord learned about my preferences for how noisy to be in scheduled task follow-ups:

Compliance and permissions

SAK_ATAK 3 hours ago | prev | next [–]
I don't understand how this is gonna fly for enterprise security and compliance. Claude needs to inherit permissions from somewhere, and those permissions will never align with the members of a slack channel. And finding the lowest common denominator of access probably results in a dumbed-down, useless experience.
The only way it works is if customers truly start treating agents as humans with the same liability as an employee.

Permissions are exactly the kind of problem Letta is designed to make explicit. Slack apps and agents can all be scoped separately -- we have some agents with secure access to credit cards that run on sandboxed machines, some that don't live on our cloud, and others with different accounts and permissions schemes.

Letta agents are provisioned in a similar way to people, so all your company's tools and policies apply.

Teamwork

SweetSoftPillow 5 hours ago | prev | next [–]
The most important difference from other products:
@Claude is multiplayer. Within a given Slack channel, there’s one Claude that interacts with everyone. This means that anyone can see what it’s working on, and can pick up the conversation from where the last person left off. This makes tagging Claude very different from working within a single chat or for a single task—it’s much more like interacting collaboratively with a teammate.

This is the same with Letta, with the important distinction that each agent learns and grows separately depending on how it is used.

For example, our R&D team has an agent named Noam that specializes in the AI/ML tasks they need to accomplish. Brad, our gen-z gym-bro office manager agent is very good at working with DoorDash since it orders us lunch every day.

If Claude is one teammate that Anthropic controls, Letta agents are teammates that can grow within your organization. They are also not beholden to the whims of Anthropic -- if they yank a model, get hit with regulatory banhammers, or change their usage policies, you have to deal with the fact that your company is molded around their architecture.

Not the case with Letta. Everything is open source, memory is easily portable, deployable on your own infra (though we'd love it if you help us build out our Constellation), and one click away from using a different model.

Cost

holografix 1 hour ago | next [–]
Wowza this will be a token guzzler. Assuming Claude is parsing every message posted on multiple slack channels, compacting knowledge etc.
Looks like Anthropic is progressing further into platform territory and conquering Agentic use cases left right and centre. If you’re building an agent platform for workforce productivity today, your best best is model agnosticism and focus on token cost control.

Claude is expensive, and Slack can make cost feel scary because people imagine every message in every channel being parsed, summarized, and remembered.

Letta gives you more control over that:

  • Channels are explicit. You choose which agents listen where.

  • Models are swappable. Use Anthropic, OpenAI, open-weight models, local inference, or cheaper models for background work. Conversations with the same agent can even run on different models.

  • Usage is attributable. Our Dashboard shows usage by agent.

  • Memory work can be asynchronous. Reflection and summarization do not need to run on the same model as the main task.

The important point is not that one model is always cheaper than another. It is that your company should control the model/runtime/cost tradeoff instead of inheriting it from a single vendor.

Get started

Want to try Letta out?