# Your team's decisions live in Slack. Slack is not memory.

*Slack search finds messages, not conclusions. Why dev team decisions need identity and lifecycle, and recall that returns only what still holds.*

Someone asks in the platform channel why uploads bypass the CDN. You know this was settled. You were in the thread. So you search "uploads CDN" and get two hundred matches, the original argument, a retro where it resurfaced, an unrelated joke. Somewhere in there a staff engineer wrote "fine, let's ship it that way" and the thread went quiet. Which way. The message doesn't say. The actual conclusion happened in the huddle that followed, and Slack never heard it.

This is not a search quality problem. Search over scrollback can only ever return messages, and a decision is not a message. A message has an author and a timestamp. A decision has an identity, the part of the system it governs, and a lifecycle, because the team will change its mind and the old answer has to visibly lose to the new one. Scrollback has neither. Pinning and canvases don't add them, they add hand-maintained snapshots that rot the moment the next thread overrides them, the same drift that [separates docs from reality](https://kgai.dev/blog/decision-drift). And your AI agents never read the scrollback at all. Each session starts cold and re-derives, which is how [a teammate's agent ends up solving a problem the team already solved](https://kgai.dev/blog/teammates-ai-solves-it-again).

This gap is what we built kgai for, so from here you're reading the makers. kgai keeps a team's engineering decisions in an append-only, immutable decision log. Each decision attaches to named elements of your system, so "uploads bypass the CDN" becomes a statement about an element with an identity rather than a sentence adrift in a channel. A change of mind is a new decision that supersedes the old one through an explicit link carrying the reason. Recall returns only decisions in force, while the losers, dead ends included, stay queryable for anyone asking how things got this way.

The log projects into a small graph deterministically, and recall is lexical matching plus graph traversal, with no embeddings in the read path, so the same store gives the same answer on every machine. No daemon, no server. Capture happens at the write boundary, through a skill and hooks in the Claude Code plugin, meaning the session that makes a choice is the one that records it, and a standalone kg CLI covers the rest. Team sync is opt-in through an S3 bucket you own, where every writer appends to their own shard, so parallel writes never produce a textual conflict. MIT licensed.

It also holds up at volume. At a million decisions across thirty writers' shards, a decision lookup still answers in about 100 ms, though recall and free-text search are slower than that.

Slack is where the argument should happen. Just stop asking it to remember who won.

## Try kgai

Two commands, MIT, nothing leaves your machine until you configure a bucket:

```
claude plugin marketplace add kgaidev/kgai
claude plugin install kgai@kgai-marketplace
```

Source: https://github.com/kgaidev/kgai
See how kgai compares to other tools: https://kgai.dev/compare
All notes: https://kgai.dev/blog/

---

Canonical: https://kgai.dev/blog/slack-is-not-memory · Written by kgai maintainers · kgai is MIT open source