New features that are still being tried out start off, with a switch under
experiments in runner.json (the user guide, "Experiments", says how to turn one
on). These are the ones there are now.
- Decisions on the Projects page (
projectDecisions, since 10 Nov 2026). Every question your threads are waiting on you for, gathered by project. On the Projects page a project's card says how many decisions it has ("3 decisions"). The sidebar's Projects view becomes one row a project: its icon and name, its decisions in orange when it has any (else how many threads it has), and a chevron that shows its threads under it or hides them again. Clicking the rest of the row opens the project's page. Every project starts folded, and each remembers whether you left it open; Not in a project folds the same way. Open the project and its page is in two tabs at the top, Decisions (with how many are waiting, its parts' too) and Project (its parts, goals, state, notes, tasks, folders and threads). It opens on Decisions when something's waiting and on Project otherwise, keeps the tab you last picked for each project while the app runs, and if the decisions all get answered while you're on that tab it says "Nothing waiting" there rather than jumping away. ⇧⌘[ and ⇧⌘] (Go menu) move between the tabs. The Decisions tab has a card for each thread waiting on you, with the thread's title, a line on what it's doing, its questions just as the thread shows them (the Recommended star and Something else too), and Open thread for the whole story. Pick an answer and it goes to that thread exactly as if you'd answered it there: the card says "Sending to" the thread with a spinner, then drops off the list once the thread takes it. A card with several questions sends once each has an answer; with Something else, press Return in its box (⌘Return sends whatever's answered). Nothing new runs and nothing is relayed: each question stays in its own thread. The inbox is as before. Mac app only for now; the phone and the website don't have the page yet. - Nested threads (
nestedThreads, since 15 Nov 2026). Threads another thread started sit indented under it in the sidebar, like sub-agents, instead of having rows of their own across the inbox. The group sits where its most urgent member would: in the inbox if any of them needs you, in Running if any is working, otherwise where the starting thread is. It opens by itself when one of them has a question for you and folds otherwise, saying how many are working. Each one opens with a line saying which thread started it and why. An agent can start a thread that isn't part of its work as one of its own, and you can move a thread out from under its starter, or back, from its menu. The starting thread no longer wakes for each report its threads send it: they're kept until all of them have finished (or one fails), then come to it together. Mac app only for now. - Shared memory (
sharedMemory, since 17 Nov 2026). A thread on your main Mac knows you mostly from what Claude Code loads before your first message: your globalCLAUDE.md, and the memory folder of the project it's in (MEMORY.mdand the notes agents save as they learn things). Without this, those stay on the main Mac, so a thread on another runner starts knowing nothing about you. With it on, the main Mac puts them up to your backend every minute, and each other runner copies them into its own Claude logins (and the global file into Codex'sAGENTS.md), under its own home folder:~/dev/me/misc's memory on the main Mac becomes~/dev/me/misc's on the other runner too. Only folders under your home folder go, not~/Library. A file that was on the other runner before sync wrote it is left alone. When an agent on another runner saves a memory, or changes one the main Mac sent, it's sent back as an offer, not written into the main Mac's memory (its own edit stays there until the main Mac has a newer version): offers land inmemory-offers/<runner>/in the main Mac's data dir, for you or a scheduled job to fold in or drop. Another runner's key can't change what the main Mac's agents read. Secret values the runner knows of are masked before anything goes up. Turn it on on every runner ("experiments": { "sharedMemory": true }in runner.json): the main Mac to put its files up, the others to take them. - Inbox guess (
inboxGuess, since 18 Nov 2026). Finds out which finished threads you didn't need to see, without hiding any. On the done card, Archive opens a small menu: "Didn't need this" (the agent only did what you'd told it to, and the thread could have gone straight to Archived), "Glad I saw this", or "Not sure" for the in-between ones, which is kept but not scored. Each archives the thread as before, and leaves a line in it saying which you picked. ⌘E, a row's archive button and a swipe still archive straight off, with no menu. Meanwhile, each time one of your own threads finishes with nothing for you, two models (a cheap one and a strong one) each guess whether you needed to see it, from your last message to it and the agent's reply. A thread that suggested follow-ups or left anything open always counts as one to see, with no model asked. The guess does nothing and shows nowhere: the thread stays in your inbox either way. The guesses and your picks are written toinbox-guess.jsonlin the runner's data folder, so you can see how often a model would have been right before letting it archive anything. Threads in a private folder aren't sent to a model. Threads on another runner, and archives from the phone or the website, aren't part of it yet. - Pull requests in the side pane (
inlinePrs, since 18 Nov 2026). A GitHub pull request link clicked in a reply, or in Highlights' Links, opens as a tab in the pane beside the thread instead of your browser (⌘-click still goes to the browser). A PR link in a reply has GitHub's pull request mark before it, green while it's open, grey as a draft, purple once merged and red if closed. The tab has the PR's title, who opened it and when, its branch with lines added and removed, its status (approved, changes asked for, conflicts, merged, closed), and its checks, with any that failed named. Below that: the description, comments and reviews, and a box to comment on GitHub. Diff shows every changed file, each folding open or shut; Checks lists each check with its time, and clicking one opens its log. Review approves it or asks for changes (with what you typed in the comment box), and Merge merges it the way its menu's Default says (rebase, squash or a merge commit, whichever the repo allows). Close without merging is at the bottom. Every button spins until GitHub has answered, then the PR is read again. Start a thread puts the PR in a new thread's message box in the same folder; Ask Claude to review starts a thread there that reads the PR and says whether to merge it, without touching it on GitHub. Resting the pointer on a PR link starts reading it, so it's usually there by the time you click, and so does opening a thread whose last few messages link to PRs, or a turn ending with one. Grey shapes show where the PR will go while it's read, and the PR shows while its changes are still on their way. A PR you've opened before shows straight away as it was last time while it's read again, with its buttons waiting until GitHub has answered; one read more than a minute ago is read again behind it each time you open it. The app keeps the last 200 PRs it read in its cache folder for this. Each PR you open stays as a tab at the top of the pane until you close it, and Back goes to Highlights. It uses the gh command line tool, signed in as whoevergh auth loginmade it, so it needs gh installed and signed in. Desktop (GPUI) app only. - Live pages (
livePages, since 19 Nov 2026). An agent can show you something that moves or that you can turn around (a 3D model, an animation, a small simulation) as a live page: one self-contained HTML file it puts in its reply like a picture,. The thread shows it as a card with Run, on the Mac and on the iPhone (it goes up the way pictures in replies do, at most 10 MB; the Android app and the website don't run them yet). Run starts it there in the card, for that version of the page; on the Mac it shows while the whole card is in view. It stays sealed off: it can't reach the internet or read any file but its own, and it can't open anything. A page an agent only pins stays on the Mac. - Virtual runners (
virtualRunners, since 19 Nov 2026). Runs on in the new-thread box lists your virtual runners after your Macs, for example Cloud (Fly): a thread started there gets a box of its own in the cloud, which clones the folder's repo and runs Claude Code there, sleeps when the thread's idle and wakes for its next message. The first time a thread runs on one with a Claude login that has no cloud token, the thread shows a card: Make one runsclaude setup-tokenfor that login and opens claude.ai to approve it, or paste one, or use that login's year-long token from this Mac. The message waits and goes once the token's set, and the card comes back if Claude ever refuses the token. A virtual runner has to be set up in your Convex backend first (docs/virtual-runners.md). - Agent Archive (
archive, since 20 Nov 2026). For people running Agent Archive, Mike's archive of every agent conversation, which isn't public yet: without it installed, this only keeps a list. Every ten minutes the runner writesarchive-sessions.jsonin its data folder, saying which Claude or Codex session belongs to which Threadbear thread, with the thread's title, project and folder, and where each of your Claude and Codex logins keeps its sessions, so a login you add is archived too. Agent Archive's sync reads that list and sends it to the archive with its own credentials, so search results and the archive's reader can open the thread in Threadbear. The runner also reads the sync's state fortb statusand says when it has stopped. When runner.json'sarchive.reponames the archive's git repo, the runner builds the sync from its main whenever main moves and installs it with the archive's own installer, then on the machines inarchive.pushToover ssh. A machine running the archive server leaves that to the server's own deployer. The sync stays a background service of its own, so the runner restarting never stops it mid-upload. The plan for the rest is in docs/agent-archive-plan.md. - Email watcher (
mailWatch, since 20 Nov 2026). Every few minutes the runner runs a command of yours that prints your new emails, and a small model sorts them against your threads. An email a hibernating thread was waiting on (a reply, an approval, a delivery) wakes that thread with the email, and its agent checks it really is what it waited for. An email about an open thread's work is kept for that thread: a note in it says so, and its agent reads the email on the thread's next turn, without one being started for it. When one of your standing decisions (files you name, such as a memory index) clearly says what to do with an email, and a stronger model agrees, it's done straight away in the thread it belongs to or a new one, which archives itself when finished; at most four a day, and never sending, posting, paying or deleting unless the decision says exactly that. Anything else that looks like it needs you goes on a list, which comes as one thread at 9 am and 4 pm (or the times you set), with a suggested action for each and what was done without asking since the last one. Newsletters, receipts and notifications are left alone. Only the main Mac's runner looks. It needsmailWatchin runner.json:command(prints a JSON list of emails, each withid,from,subjectand the start of itstext, and optionallyaccount,date,urlandthreadId; it getsTHREADBEAR_MAIL_STATE, a file it may keep its place in), and optionallyeveryMinutes(5),digestAt(["09:00", "16:00"]),folder(where new threads start; your home folder),decisions(files of standing decisions; none means it never acts) andact: falseto never act. The runner holds no mail login: the command reads the mail. The sender, subject and first 1,500 characters of each new email go to the model, with your recent threads' titles and briefs (never a private folder's). - Warm start (
warmStart, since 20 Nov 2026). When you open a new thread (⌘N or the new-thread button), the runner starts its Claude Code straight away, while you write, instead of after you press Send. Claude Code takes about half a second to start, so the first reply of every new thread comes that much sooner. If you change the folder, login, model, effort or mode before sending, it starts another to match; if you quit the app or don't send within ten minutes, it stops. Until you send, it holds the memory of one more Claude Code (about 150 MB) but makes no requests. Claude threads only, in a folder as it is: one that gets a worktree, or a thread started in a project, starts as before.
For forks (docs/forking.md). Each one's switch is experiments.<id> in runner.json, and
its own file is runner/src/experiments/<id>.md, which goes with it.
| Experiment | Lives in | Taking it out |
|---|---|---|
Decisions on the Projects page (projectDecisions) |
app/Sources/ThreadbearCore/Threads/ProjectDecisions.swift (which threads, the counts, the line on what each is doing), decisions in ProjectCardStatus (ProjectCards.swift); the Decisions section and its cards in app/Sources/Threadbear/Views/ProjectDecisionsView.swift, shown from ProjectPage.swift, the counts in ProjectsHome.swift, the folded sidebar rows in ProjectsList.swift (ProjectFoldRow) with app/Sources/ThreadbearCore/Threads/ProjectFolds.swift and openProjectRows in AppModel.swift; the page's tabs in ProjectPage.swift (ProjectTabBar) with app/Sources/ThreadbearCore/Threads/ProjectTabs.swift, projectTabsPicked in AppModel.swift and the Go menu's Show Previous Tab and Show Next Tab (previousTab, nextTab in Shortcuts.swift); pickDecision, sendDecision and decisionSends in AppModel+ThreadActions.swift and AppModel.swift. In the GPUI app: the Decisions tab and its cards in desktop/gpui/src/project_decisions.rs, the tabs in project_page.rs, the tab rules in desktop/core/src/projects.rs, and previousTab, nextTab in desktop/core/src/shortcuts.rs. The app learns it's on from hello's experiments. The runner keeps nothing of its own for it: thread summaries already carry their asks, the line is the thread's latest headline, and answers are an ordinary threads.send. |
Delete ProjectDecisions.swift, ProjectFolds.swift, ProjectTabs.swift and ProjectDecisionsView.swift, ProjectTabBar and the two tab commands, ProjectFoldRow and openProjectRows, the projectRow automation key, the projectDecisionsOn checks in ProjectPage.swift, ProjectsHome.swift, ProjectsList.swift and Projects.swift, decisions in ProjectCards.swift, the Decisions part of AppModel+ThreadActions.swift and decisionSends, and the decision automation command and projectDecisions in dump. Nothing in the runner or the backend changes. |
Nested threads (nestedThreads) |
runner/src/runner/nested.ts (holdReport, settleHeld, takeHeld, called from send, completeTurn, update, delete in runner.ts, deliverWaits in runner/hibernation.ts and the start in main.ts); detached and heldReports on the thread's record (store.ts), detached on threads.create and threads.update (rpc.ts) and create_thread's nested; in the GPUI app, the grouping in desktop/core and the sidebar and the "Started by" line in desktop/gpui |
Delete nested.ts, its entry in the parts list and the Runner interface in runner.ts, the holdReport and deliverHeld lines in send, the settleHeldSoon calls, takeHeld in deliverWaits, the held reports start step, heldReports in store.ts, and the GPUI app's grouping and "Started by" line. detached can stay: it's harmless without the sidebar reading it. |
Shared memory (sharedMemory) |
runner/src/memory-sync.ts (scanning, writing down, offers, the minute timer), memoryBackend and the attach in runner/src/sync.ts's heartbeat, its construction in runner/src/main.ts. In the backend: convex/memorySync.ts, the memoryFiles, memoryOffers and memoryOfferCounts tables in convex/schema.ts, and putMemory, memorySince, offerMemory, memoryOffers and takeMemoryOffers in convex/sync.ts (API 84). The runner keeps memory-sync.json and memory-cache/ in its data dir. |
Delete runner/src/memory-sync.ts and its test, memory in ConvexSync's deps, memoryBackend and its attach line in runner/src/sync.ts, and memorySync in runner/src/main.ts. In the backend, delete convex/memorySync.ts, the five functions in convex/sync.ts and their rows in ACCESS (convex/runnerAccess.ts) and in docs/protocol.md's table, then the three tables once they're empty. Files sync wrote on other runners stay where they are. |
Inbox guess (inboxGuess) |
runner/src/runner/inbox-guess.ts, called from completeTurn, start and update in runner/src/runner.ts and from adopt in runner/src/runner/handovers.ts; the three verdicts didntNeedToSee, gladISaw and notSure (runner/src/protocol.ts); the Archive menu in desktop/gpui/src/composer_card.rs and MenuAction::ArchiveAs (desktop/gpui/src/sidebar.rs) |
Delete runner/src/runner/inbox-guess.ts, its three calls in runner.ts, the one in handovers.ts, and its part in the Runner interface and the parts list, inboxGuess on the thread record (store.ts), the three verdicts and their notes, and in the desktop app inbox_guess_on, open_archive_menu and MenuAction::ArchiveAs, so Archive is a plain button again. |
Pull requests in the side pane (inlinePrs) |
runner/src/github-pr.ts (reading a PR, its diff and its repo's merge methods through gh, and the merge, close, reopen, comment and review actions), the github.pr, github.prFiles, github.prStates and github.prAct requests in runner/src/rpc.ts. In the GPUI app: the tab in desktop/gpui/src/pr_view.rs, Target::Pr and the Merge and Review menu actions in highlights.rs, its arms in files.rs, the link click and the read started by resting on a link (preload_pr) in reply_links.rs, the reads as a thread shows or a turn ends (preload_recent_prs) in thread.rs, the copy kept between runs (mod cache in pr_view.rs, in ~/Library/Caches/Threadbear/prs), the marks before PR links in replies (PrMarks, put in by with_link_marks in chips.rs) (open_pr_link, and the starred merge method in its prefs), and the rules and words in desktop/core/src/pull_requests.rs. The app learns it's on from hello's experiments. |
Delete runner/src/github-pr.ts and its test, the four github.* cases and reqPrRef/ghCall in rpc.ts, and "Pull requests" in docs/protocol.md. In the app delete pr_view.rs and core/src/pull_requests.rs, Target::Pr and its arms, PrMarks and the PR half of with_link_marks, the PrMerge, PrMergeDefault and PrReview menu actions, the prs field on SidePane, the PR checks in SidePane::follow_link and ThreadPane::follow_link, pr_merge_method and preload_pr in reply_links.rs, and preload_recent_prs and its calls in thread.rs. |
Live pages (livePages) |
runner/src/share-images.ts (PAGE_TYPE, sniffPage, replyImagesInEvent's pages), livePages() and the upload in runner/src/sync.ts, REPLY_TYPES in convex/sync.ts and mediaType in convex/share.ts's phoneImage; the Mac's card in desktop/gpui/src/live_pages.rs (with live_page in web_panels.rs and PreviewSite::live in desktop/web), the iPhone's in ios/Threadbear/LivePageView.swift. docs/live-pages-design/README.md has the plan and what's built. |
Delete the file, PAGE_TYPE, sniffPage and the pages argument in share-images.ts, livePages() in sync.ts, text/html from REPLY_TYPES in convex/sync.ts, live_pages.rs and its plugin and markdown::live_pages call in rows.rs, live_page/close_live_pages in web_panels.rs, PreviewSite::live and workers, LivePageView.swift and its branch in ThreadView.swift. |
Virtual runners (virtualRunners) |
runner/src/virtual-runners.ts and cloud-token-helper.py (starting a thread on one, and cloud tokens), virtualRunners in runner/src/main.ts and runner/src/sync.ts (virtualRunnersReady), watchServices in runner/src/thread-index.ts; in the GPUI app, the Runs on entries, the rows' box states and the token card; the backend's convex/boxes.ts, boxService.ts, boxMachine.ts and cloudTokenMachine.ts, and box mode (runner/src/box-mode.ts). |
Delete virtual-runners.ts, cloud-token-helper.py, the cloudTokens.* methods and virtualStart in main.ts, watchServices and services in thread-index.ts, and the app's Runs on entries and token card. The backend's boxes can stay: with no virtual runner made, nothing runs. |
Agent Archive (archive) |
runner/src/agent-archive.ts (the list, the status and the updates; formatArchive is tb status's line); started in main.ts beside the email watcher, with archive in runner.status; ArchiveStatus in restart.ts; runner.json's archive in config.ts |
Self-contained: delete agent-archive.ts and its test, its lines in main.ts, restart.ts, tb-dev.ts and config.ts, and archive-sessions.json and agent-archive-update.json from the data folder. Agent Archive's own sync carries on as it was, without thread names. |
Email watcher (mailWatch) |
runner/src/mail-watch.ts (the looks, the sorting, the pile and its list), runner/src/runner/mail.ts (which threads, waking one, keeping an email for one), the takeHeldMail call in deliver in runner/src/runner.ts, heldMail in runner/src/store.ts, mailWatch in RunnerJson (runner/src/config.ts) and its construction in runner/src/main.ts. It keeps runner/mail-watch.json in the data dir. |
Delete mail-watch.ts, runner/mail.ts and their test, mailPart and MailPart in runner.ts with the takeHeldMail lines in deliver, heldMail and HeldMail in store.ts (and its entry in OBJECT_LISTS), mailWatch in config.ts, and the MailWatch block and its stop in main.ts. |
Warm start (warmStart) |
runner/src/runner/warm-start.ts (with threads.warm in runner/src/rpc.ts, sessionOptions and the takeSpare call in startSession in runner/src/runner.ts, and draftRecord and the warmId in runner/src/runner/new-threads.ts); in the app, warm_new_thread in desktop/gpui/src/new_thread.rs |
Delete warm-start.ts, the threads.warm case and the dropSpare call on a closing connection in rpc.ts and rpc-gate.ts, the takeSpare call in startSession (keep sessionOptions), the warmId handling in create, the dropSpare calls in shutdown and handovers.ts, and the app's warm_new_thread and the warmId it sends. |