Team chat with a memory underneath. When your team settles something, the decision and the why stay attached to the messages, so when the question comes back in three months there's an answer instead of a re-litigation. I built this because chat kept eating mine.
The same messages, grouped by topic. A discussion from three weeks ago is one card away instead of a scroll away.
Threa keeps decisions and context as short memos linked to the messages they came from. Ask Ariadne, or search, and get the memo with its sources.
Claude Code, Codex, Pi, or one you wrote. Connect it as a bot and it reads the room, answers mentions, and posts its work back.
The whole product is public. It's MIT licensed so you can help fixing what I broke. It's on GitHub.
A timeline is good for keeping up. It's bad for finding a discussion again three weeks later. The board is the same channel grouped by topic, so you open the conversation instead of scrolling for it.
Threa reads the conversation, keeps the lines where the team settled something, and saves them as short memos linked to the messages they came from. When the question comes up again, Ariadne finds the memo and the conversation behind it.
Most of a channel is noise. The parts worth keeping are usually a handful of lines where the team settles something, works out a process, or shares context they'll need again.
Nobody rereads a transcript two months later. A short, sourced memo is the part that stays useful once the thread has scrolled away.
A reason you can't find isn't worth much. When the question returns, ask Ariadne to search for the relevant memo and follow its links back to the source conversation.
The frontend, backend, control plane, and infrastructure are all public, and the public repo is the one we deploy. Read exactly how Threa works, fork it, or run it yourself. Do whatever.
The code, data model, access checks, model calls, and deployment setup.
Fork it, change the product, or run your own version on the same code we ship. I won't take it personally.
Design docs, implementation plans, and the feature list are public too. Embarrassing drafts included.
Threa ships with Ariadne, and she's useful from day one. But you probably already have an agent set up the way you like it, with your codebase and your context. Connect that one as a Threa bot instead of starting over with mine. It can even stay on your laptop behind NAT.
Mention the bot in a channel and the runtime hands the request to your local agent, then posts the reply under the bot's name. It can search messages by text or meaning, read memos and attachments, and follow a memo back to the conversation it came from. It can also take whole tasks. You delegate, watch it work in the stream, and the finished thing lands where the team can see it.
Works today with Claude Code, Codex, Cursor, OpenCode, Gemini CLI, or a bot you write yourself, through the bot runtime, the CLI, or the MCP server.
Connect a local agentPartly I built Threa out of spite. Years of watching decisions disappear into channels, plus a short list of things I wanted from a chat app and never got. So I added them.
Threads inside threads, so a tangent off a tangent gets its own space instead of taking over the parent.
A stray reply in the channel can be lifted into a thread after the fact, without copy-paste.
Reply to the exact line someone wrote, quoted inline, so the context comes with it.
A markdown composer with fenced code and syntax highlighting that doesn't mangle the snippet you paste.
Pop the composer out into a full editor for a longer message. Room to draft and edit, with no stray Enter sending it before it's ready.
Save a half-written message without sending it and pick it back up later.
A private side thread with Ariadne next to the message you're writing. Ask what the conversation actually decided, think out loud, then go back to the draft. Nobody else sees it.
The reasoning behind a call stays in a memo, ready for Ariadne to retrieve when you ask about it again.
Threa is one developer's project, built in the open. More about why.