Channels, threads, and DMs, with a memory underneath. The decisions you make and the reasons behind them stay attached to the conversation, so they're still there when the question comes up again.
A timeline is great for real-time chat. It's linear and immediate, and good for keeping up with what's latest. Where it falls short is discoverability. Once a discussion gets long or complex, it's hard to find again weeks later. The board answers that: the same messages, grouped by topic, so you can go back and find a conversation instead of scrolling for it.
Threa reads the conversation, finds the decisions and context worth keeping, and saves them as short memos linked to the messages they came from. When the question comes up again, ask Ariadne to search workspace memory for the relevant memo and its source conversation.
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. Read exactly how Threa works, fork it if you want your own version, or run it yourself. The public repo is the one we ship.
The code, data model, access checks, model calls, and deployment setup are all there on GitHub.
It's MIT-licensed. Fork it, change the product, or run your own version on the same codebase we deploy.
Design docs, implementation plans, and the feature inventory are public too, not just the finished code.
Threa ships with Ariadne, useful from day one. But you've probably already got an agent set up the way you like it. Connect that agent as a Threa bot and it can stay on your laptop behind NAT, answer @mentions, search messages, memos, and attachments, and post its work back into the conversation.
Mention the bot in a channel and the runtime sends the invocation to your local agent, then posts its reply under the bot's identity.
Your agent can search messages by text or meaning, read memos and attachments, and follow every memo back to its source messages.
Delegate a task, follow its progress in the stream, and get the finished work back where the team can see it.
Ariadne is here to get you started. The agent you rely on can stay on your machine, with your work reachable from it instead of locked inside one more app.
Partly 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. Not one draft stuck in the input box, but a stash you can pull from.
The reasoning behind a call stays in a memo, ready for Ariadne to retrieve when you ask about it again.
Building Threa in the open.