Threads

Conversations that resolve.

A thread is one question, scoped to one channel, that ends with a real output — a Linear ticket, a Notion page, a calendar event, or a versioned artifact. Not a chat log. A resolution.

Threads

Conversations, scoped to a single thought.

Channels keep the topic. Threads keep the question. A model that lives inside a 200‑message ChatGPT history goes blurry. A model living inside a sharp, scoped thread stays sharp.

Learn more

One channel. Many threads. Each one its own room.

Resolve a thread when you’re done. The agent stops re‑reading it on every turn — but the index still remembers it for next time.

#healthHealth, fitness, nutrition
You
Do I have a food / diet plan yet?
7 replies · resolved
You
Is this week's symptoms a real UC flare?
51 replies · resolved
You
Why did my GI wave off the calprotectin bump?
14 replies · active
Thread · flare vs. stress14 replies
You
Why did my GI wave this off?
Rx
Rex
Because the number is still low. Calprotectin under 150reads as remission, and yours is 48. But the bump tracks the February pattern — launch sprint, sleep under six hours, symptoms by day five. That’s the signal, not the lab.
Rx
Rex
I’ve updated your profile — “Active Conditions” now logs this as a partial flare and the sleep‑deficit trigger. The diff is in version history.
Shape

One thread, one question, one channel.

A thread holds the context for a single question and resolves to a single output. That constraint is the magic. The model doesn’t blur because there are 200 messages from twelve unrelated topics in the window — it sees the thread, scoped to the channel, with the artifacts and profiles the channel says to load. The same model, with sharper input, produces sharper output.

Chat in ChatGPT

200 messages. Twelve topics. The model bleeds tone and context across all of it.

Thread in Boardbox

One question. One channel. The agent walks in with the right files already loaded.

apply_artifact_update·RFC-014 → new version v9propose_service_action·linear.createIssue("Pgbouncer migration")propose_service_action·gcal.createEvent("RFC review · Friday 4pm")
Resolution

Every thread points at a real output.

When you start a thread, Boardbox asks (implicitly): what will this resolve to? An artifact update, a Linear ticket, a Notion doc, a calendar event. The thread tracks its target. When the answer is good enough, you close it. Internal artifacts update with version history; external actions still require approval before they push.

Summarization

Closed threads feed the channel index.

When a thread resolves, a small model runs over its messages and writes a short summary. The summary lives in the channel index — the table of contents your agents read every turn. The next thread in the same channel can reference the work that came before without you re-explaining and without the agent re-reading 200 messages.

Sliding window

The agent always sees the most recent ~30 messages in full.

Rolling summary

Older messages compress into a running summary maintained by Haiku.

Closed-thread index

Resolved threads live in the channel index, ready to be referenced.

Reuse

Promote a thread into a scheduled agent.

If a thread is the kind of work you’ll repeat — morning standup, weekly investor brief, daily ad report — hit Make recurring. Boardbox extracts a brief from the thread, proposes a schedule and a tool set, and you land in the agent review screen. The conversation you just had becomes the agent you didn’t have to design from scratch.

FAQ

Common questions

How is a thread different from a chat?
A chat is one long conversation that drifts across topics. A thread is one question scoped to one channel, with an expected resolution. When the question is answered, the thread closes and resolves to a concrete output — a Linear ticket, a Notion doc, a calendar event, or a new version of a living artifact.
What happens when I close a thread?
Closing a thread triggers the resolution flow. Internal artifacts and profiles can be updated as versioned Boardbox changes; external pushes like Linear tickets, Notion docs, or calendar events are shown for approval before anything leaves the workspace. The closed thread is summarized into the channel index so future threads can reference it without re-reading 200 messages.
How long are threads kept?
Forever, by default. Threads are first-class persistent data, not transient sessions. The channel index keeps short summaries so the agent can recall them cheaply on later turns.
How do thread summaries get generated?
When a thread closes (or grows past a certain length), a Haiku-class model runs over the messages and writes a short summary. That summary lives in the channel index. The full transcript is still stored — the summary is what the agent reads on later turns instead of the full backlog.

The chatbox was a phase.
Build a workspace.

Boardbox keeps your context, holds its ground, and produces work that lasts.

Get started