How to Deploy a Letta Agent to Slack in 30 Minutes

November 6, 2026

Letta ships a Slack connector that attaches an agent to a workspace, so people talk to it in a channel or DM and it keeps memory between conversations. Setup is roughly 30 minutes on the hosted platform: create the agent, connect Slack, restrict tools, test memory scoping.

What should the agent actually do before you connect it?

Define two things first: the job and the memory scope. An agent with no job drifts, and an agent with no memory scope remembers one user’s details and repeats them to the next.

The scope question is the one that bites. Letta agents keep memory per agent by default. If a single agent serves a whole Slack workspace, every user’s conversation flows into the same memory — which means user A can ask “what did you tell the last person?”.

Fix it with one agent per user, or with a shared agent whose memory blocks are keyed to the user id and never merged. The first is simpler and safer.

How do you connect the agent to Slack?

  1. Create the agent in the ADE and test it in the web chat first. Do not debug in Slack.
  2. Install the Letta Slack app to your workspace, or register your own Slack app with the bot scopes the connector needs.
  3. Attach the agent to the workspace and pick which channels it listens to. Start with one dedicated channel, not #general.
  4. Restrict tools. Remove archival delete and anything that can write outside the agent’s own memory until you trust it.
  5. Send a test message and confirm a reply within a few seconds.

The web chat test in step one saves the most time. Slack adds a second failure surface — scopes, channel membership, event subscriptions — and you do not want to diagnose both at once.

How do you keep memory per user?

If you need one shared agent, key everything to the Slack user id. In the memory block description, tell the agent explicitly to store facts as “the literal user id followed by the fact”. Retrieval and injection then filter on that prefix.

The safer route for teams under a few hundred people is one agent per user, created lazily on first message. Memory stays physically separate, and deleting one user’s data means deleting one agent.

Whatever you choose, test it. Two people, two different facts, then ask each about the other. If the agent knows, the scope is wrong.

What permissions should you remove?

A Slack agent has access to whatever tools you attach. Defaults usually include archival insert and search, which are fine, plus conversation search, which can expose other threads in the same agent.

Remove any tool that writes outside memory. Do not give it a shell, a web request tool, or a database connector until you have a specific reason and a specific guard.

Also constrain which channels it responds to. An agent that replies to every message in every channel quickly becomes noise, and Slack’s rate limits will start rejecting its calls.

What breaks in production?

Long Slack threads. The connector passes conversation context, and a 200-message thread will fill the context window. Cap the thread length it reads, or instruct it to rely on archival memory instead.

Rate limits. Slack’s API limits per-channel message volume; an agent that posts status updates per tool call will hit them. Batch those into one message.

And silent memory growth. Without a cleanup routine, per-user agents accumulate stale facts. Schedule a monthly job that summarises and rewrites blocks rather than appending forever.

What does it cost?

The open-source core is free to self-host; the hosted platform charges monthly plans plus model usage. Model tokens dominate — every Slack message re-sends core memory, so a 3,000-token core block multiplied by a busy channel is a real bill.

Start on the smallest plan, watch token usage for a week, then decide. The per-user agent model multiplies memory storage but not token cost per message.

Who is this for?

  • Teams who want an internal assistant that knows their context and keeps it.
  • Support teams with a Slack-based workflow who want answers tied to a customer history.
  • Builders prototyping a memory-enabled product before committing to a front end.

Not for: public-facing Slack communities where a per-user agent model would be expensive, or organisations without a policy on storing employee conversation data in agent memory. That policy question comes before the technical one.

Quick Summary

  • Letta’s Slack connector attaches a memory-enabled agent to a workspace in about 30 minutes.
  • Decide memory scope first: one agent per user beats a shared agent with merged memory.
  • Test in the web chat, then Slack — debugging both at once wastes an afternoon.
  • Remove tools that write outside memory and constrain which channels it answers.
  • Every message re-sends core memory, so block size is the main cost lever.

Supported models, the ADE, and cloud plan details are on the Letta tool page.

Tags: