Changelog. Every release of the Mac app.
ThreadGrid checks for updates on its own and asks before it restarts. Work in progress picks up where it left off.
v3.8.0Latest
Images where you mean them
- Insert image reference chips at the caret through the file picker, paste or drop. Thumbnails stay above the draft; ordered references stay among your words through sending, history, restart, retries and task handoffs.
- Stable explicit mappings reach Claude image content and Codex image inputs. Repeated references reuse the same payload; unavailable or oversized images have an explicit local-file fallback or missing state.
- Image drafts recover locally with their text. Cut/paste reordering, undo/redo, duplicate filenames and missing-image checks preserve the association without fetching remote image URLs.
Clear verification handoffs
- Human-only checks, unavailable platforms and post-delivery requirements now get an actionable verification handoff instead of a misleading generic retry. Executable fixes stay separate, and completed branches and unmet criteria remain intact.
- Record new evidence or a newly available capability before rechecking. Repeated submissions are deduplicated; evidence never automatically passes or waives QA. Real execution errors retain their failure/recovery path.
Know what’s left
- A compact sidebar glance names the next-work account and its tightest fresh, provider-reported allowance window. Expand the sidebar for labels, or open details for every account, individual windows, reset times and report freshness.
- Unknown, partial, stale, disconnected, signed-out and API-account states stay explicit. Subscription allowance is never inferred from local token/cost totals or API budgets. Known provider limits override fresh-looking percentages; reported windows remain inspectable.
- Confirmed identity changes cannot inherit another account’s cached allowance. Missing identity metadata cannot silently clear a live rejection. Opening usage details starts no provider calls; explicit refresh reuses existing metadata integrations with singleflight/cooldown protection.
Updates that stay out of your way
- Routine discovery, no-update results and background connection failures stay silent. A constant-size header control replaces the layout-shifting banner and indicates a discovered update without moving your conversation.
- Ready-version attention is deduplicated per app session; repeated polling and refocus do not reopen a dismissed version. Explicit manual checks still show their real progress and result. Discovery remains bounded polling, not instant push.
- App-owned install and restart confirmations now use ThreadGrid’s custom interface for idle teams, active work and pending restarts. Keep working, Escape, close and Back cancel approval; failed resume stays visible with a retry action. macOS-required security prompts remain system-owned.
- Native single-use consent is bound to the verified version, engine and work revision. Changed work requires fresh confirmation even when teammate names/counts are unchanged. Cancellation remains safe before the engine acknowledges a pending restart; signature, atomic replacement and active-work safeguards remain required.
Pick up the next thread
- A custom in-app updater brings release notes, installed-to-latest version, real download bytes, signature verification, safe retries and your restart choice into ThreadGrid's own interface. The thread follows actual stages; unknown download totals remain indeterminate.
- Install the latest verified compatible release directly. A failed newer download or offline retry cannot quietly substitute an older cached installer. Native signature, app-identity, atomic replacement and active-work restart protections remain required.
- Faster native discovery checks after launch, on focus/reconnect and while the app is open, with power-aware background cadence and bounded offline retries. Feed and stable download links revalidate on publication. Discovery is not instant push: connectivity, sleep, ongoing downloads and CDN propagation affect visibility. Older clients retain their existing UI/cadence until upgraded.
Navigation, with room for labels
- Expand the slim sidebar into labeled navigation or collapse it back to icons. Your device-local preference survives reloads; keyboard focus, tooltips and the compact labeled drawer stay available.
Decisions with a source
- Inspect complete remembered decisions and their original requests from a conversation's context receipt. Newly recorded notes, initial excerpts and notes actually read in full are distinguished; unknown or deleted sources are shown honestly.
- Workers can retrieve complete and older notes through the existing memory tool. Bounded catalogs preserve full records without placing every note into each prompt. Current requests and approval gates take precedence; a remembered summary never grants permission.
- Durable source ordering keeps future decisions out of historical retries, including after source deletion, database maintenance and restart. Existing notes, projects and conversations are preserved.
Keep your answer
- Recover inline answers, send-back feedback and recovery notes after closing their editor, moving between views or ordinary reload. Reopening an action restores its draft without sending or starting work.
- Clear saving, restored and storage-failure states distinguish local Mac storage from this browser. Keep & close retains text; Discard draft clears the observed revision; explicit save retry handles denied writes.
- Failed fallback answers retain their exact text. Versioned drafts protect newer edits from stale acknowledgements and older-window discards, with one shared note-send lock inside each window.
- Decision drafts are scoped to project, task, intent and decision occurrence; dashboard drafts also include the account and connected Mac. Recovery lasts 30 days, with best-effort expiry cleanup on later storage access. Drafts do not sync across devices or live-merge between windows.
Release dependency maintenance
- Update the MCP SDK to 1.32.0 and Vite to 8.3.3 to address the release audit’s high-severity advisories. No permissions or provider routing changes.
Reliable conversation reloads
- Direct dashboard conversation links restore the selected thread and history after reconnecting to the Mac.
- Compact layouts, keyboard focus, reduced motion and explicit recovery errors remain supported. Native VoiceOver, IME and force-kill durability acceptance remain unverified.
Your turn, in context
- Find current questions, approvals and actionable blockers in a compact conversation rail. Opening it never answers, approves or starts agent work.
- Jump to the actual decision, including older history, then return to the message you were reading. New replies and resolved decisions preserve the bounded reading window.
- Large decision lists start with twelve controls and expand only when requested. Empty trays stay quiet; active writing keeps its focus.
Deliberate decisions and recoverable answers
- Approval shortcuts require focus on the decision itself or its main action. Renaming a thread or using a modal can no longer approve unrelated work behind it.
- Failed answers and recovery notes remain visible with their exact text and a retryable error. Pending replies prevent duplicate submissions and local close/navigation races.
- Thread renaming now coordinates menu closure and focus, ignores stale events for other threads, and keeps compact titles clear of header controls.
- Keyboard focus, 44px touch targets, compact dark layouts and reduced-motion states remain supported. Inline decision notes are retained while their editor is mounted; reload persistence is not provided.
From conversation to outcome
- Expand a workstream to see its assigned team, next action, definition of done and current approval boundary in the conversation.
- Inspect completion evidence separately from delivery receipts: passed, failed and skipped commands; waived criteria; QA/review warnings; and checked versus delivered revisions. Missing evidence stays explicit.
- Start hiring from an outcome and see your existing specialist, related-role and Lead coverage before exploring a role. Browsing creates no employee or paid request.
Safer, calmer daily work
- New replies preserve the message you are reading, including when a pending decision disappears. Jump to the latest when you are ready.
- Persona edits survive teammate renames and late save/default responses. Closing an unsaved editor offers keep/discard with reliable keyboard focus.
- Timeline assembly indexes shared records once and safely handles malformed ancestry and cross-project references.
Inspectable efficiency
- Repeated board/thread task context uses one lossless record with ordered references only when the complete representation is smaller. Existing instructions, limits and history recovery remain intact.
- Context receipts show exact serialized-character measurements and allow retrying a failed read. Token billing, provider cache behavior and real-model quality effects have not been measured.
A workspace for ideas in motion
- An original interlocking TG identity, matching native app icons, light/dark marks and a reusable website brand kit.
- Quote selected reply text into an editable draft. Fast reloads and thread switches preserve the latest draft without stale responses clearing newer writing.
- A more expressive workspace with a raised canvas, clearer navigation, stronger typography and focused indigo accents. Light, dark, compact layouts and reduced-motion preferences stay supported.
- Conversations have a new kickoff with your actual team, contextual starter drafts, clearer reply and recovery states, and a more deliberate composer. Brief helpers append visible structure without replacing or sending your draft.
- See who a message addresses, keep execution options in view, and get clear feedback before a request exceeds the input limit. Copy replies or follow up in one click. Voice controls also work in an existing empty thread.
Build the right team
- Guided hiring explains what each role contributes, lets you choose provider/model/effort, and previews the setup before one explicit Hire action.
- Your choices apply atomically before the teammate becomes available for work. Browsing and configuring creates no employee. Existing teammates and settings are preserved.
- The Team screen brings roles, current work and recent contributions into a responsive card layout. Custom model configuration retains the existing Mac-only boundary.
Find work and understand effort
- Command search matches all loaded, unarchived project work before limiting results, including individual steps and older threads. Existing matches rank above actions that create new work.
- Task overviews show recent agent work and verification summaries, with a direct path to the work log. Usage insights separate fresh input, cache reads and output, show tokens by stage and identify stopped runs and incomplete cost observations.
- Dependency grouping avoids repeatedly copying growing sibling lists. Measured run time is labeled separately from task wall time; no provider savings are assumed.
Updates that keep you in control
- Real download and signature-verification progress, clear retryable errors, and ordered update status across window reloads.
- Installation starts only after your active-work choice. Ordinary quitting leaves a deferred update alone; duplicate installs are blocked.
- macOS validates the app identity, Developer ID, notarization, version, OS and both executable architectures before an atomic replacement. Failed validation or replacement keeps the installed app intact without asking for administrator elevation.
- A clearer disk-image installer explains drag, launch and eject, with recovery guidance for interrupted downloads and apps still running.
More reliable conversations and work
- Long requests keep all your instructions. Inspect the context included with a reply, and let the team recover full earlier messages when needed.
- Work waiting on a teammate receives their merged changes before continuing. Pull request status refreshes correctly even after a long wait or a request for your help.
- Older conversations and long run transcripts remain reachable, with bounded pages that keep large histories responsive.
Clearer usage and limits
- Codex continuations receive changed memory, coordination and recovery context without repeating unchanged sections.
- Interrupted Claude requests retain observed usage. Usage shows fresh input, cached input, output, incomplete costs and measured local preparation/provider time.
- Concurrent Claude work reserves separate mission allowances. Unknown interrupted spending keeps its allowance reserved instead of being treated as free.
- Codex uses an asynchronous tool-work safety stop; actions already in flight may finish. Hard dollar budgets require Claude because Codex does not report dollar cost.
Verification and performance
- Dependency fingerprinting yields during repository traversal so the engine stays responsive. All independent review, QA and delivery checks remain in place.
- Release reports distinguish passed, skipped and unverified checks. Shell guardrails recognize common Git option variants and accidental reviewer writes.
- ThreadGrid 3.0 is built around one loop: open a project, say what you need, and watch it ship. Companies are now projects, and your projects, tasks, settings, accounts and Keychain entries all move over the first time 3.0 starts. Nothing is deleted.
- Threads. Ask for anything in a thread, start as many as you like (⌘N), and search them all with ⌘K. The Lead answers, starts the work and reports back in the same place. Work shows inline with one line from triage to ship, and decisions appear right where they're needed, with the main action on ⌘↵. Your 2.x conversation becomes your project's first thread.
- Nothing stuck, nothing silent. Every task that isn't running says why and when it resumes. A watchdog restarts steps that stop responding, and Retry works on any task that isn't done.
- Autopilot is one switch in the sidebar. When the team is idle, the Lead picks the next most useful improvement, says why in the Autopilot thread and ships it under the usual checks and daily caps.
- The Log shows everything shipped, grouped by day, a changelog grouped by release, and metrics: shipped versus the previous period, median time to ship, streak, tokens, lines changed and first-time review passes. Share any entry, release or period as an image card with editable post text, then copy it, save it or post it on X.
- Needs you gathers every approval and question in one place. All work lists every task across threads, as a list or a board, and each task has its own page with its steps, ship gate and tokens.
- Fewer tokens. The Lead triages in the conversation, light work runs on a faster model unless you picked one, small tasks get one combined review and QA pass, fix runs resume the build session, and prompts are trimmed.
- Spend you can see: a live token meter and per-task tokens. Budgets are off by default; turn on daily or per-task limits in Settings → Usage & limits. Limits you set in 2.x are kept and apply once you turn limits on.
- A new look across the app, threadgrid.ai and the web dashboard: a calm paper-and-ink design in light and dark, set in Instrument Sans and JetBrains Mono, with a new logo and icon. Indigo marks live work, saffron what needs you, green what shipped and red what failed.
- Uses much less of your Claude usage. Opus plans; Sonnet at medium effort does triage, building, review and conversation. Reviews skip lockfiles and build output, and long diffs are trimmed. Teammates run only targeted checks, because ThreadGrid runs the full suite itself. Prompts no longer repeat the goal.
- Each mission has a $10 budget by default. Near the limit, Raise budget appears on the card, in the task and in the inbox. If a mission does reach its budget, it stops and asks you; raising the budget picks it back up.
- Tasks no longer get lost. Work left running after an interruption is queued again. A subtask whose dependency was cancelled asks you instead of waiting forever, and retrying builds it without that dependency. Each QA round files one combined fix task. Plans that were replaced stay out of the goal. Creating the same task twice in quick succession returns the first one.
- ThreadGrid checks your repository and GitHub every minute. Each task shows its branch, how far it is ahead of or behind the base, its worktree, and its pull request with review and check status. The new Repository panel in Ships shows how far your base branch is behind, along with leftover worktrees and branches. Sync now refreshes it, and Clean up removes only leftovers that are safe to delete.
- Pull requests that wait to merge stay in step with GitHub. Commits pushed to the PR are pulled in and checked again. A PR closed without merging asks you what to do. Requested changes become a fix task when you retry, using feedback only from people with access to the repository. A branch deleted outside ThreadGrid is reported instead of being silently rebuilt. After shipping, ThreadGrid removes the task's worktrees and merged branches.
- Talk to your team while they work. Messages sent during a reply wait in a queue you can edit, reorder or send right away. ⌘Enter stops the reply and sends now. A stopped reply changes nothing and can be retried. Type @ to address a teammate directly. Tool work folds into a single "Worked for" line, and the sidebar counts unread replies.
- Call your team. Speak and the Lead answers aloud with captions; interrupt by talking. Dictate into any message box, or hear a spoken briefing of what shipped, what needs you and what's in progress. Voice settings choose the voice, speed, and whether replies are read aloud.
- The app catches up by itself if it misses an update from the engine.
- Every task says in plain words where it stands and what you can do next, on the board, in the task, in the inbox and in the command palette. The sidebar groups work by what needs you.
- A cleaner task view. The conversation sits on the left, and Overview, Work log, Changes, Checks, Preview, Files and Delivery sit behind a single row of tabs. Where the task stands is shown once, in the header, and the next step sits right under it. To steer a task, switch the message box from Note to Change direction.
- Quieter board cards show the task, where it stands and the one thing to do next. Columns with no tasks fold away, and the Ideas column stays open until the board has work in it.
- The conversation has less clutter: the room header shows what the team is doing, and the repeated links and hints are gone. The Stop button is clearly labelled while work is running, and the sidebar separates everyday places from records and settings.
- A wider task workspace pairs conversation with previews, changes, checks, references, delivery, and concurrent work. Adjust the conversation width and preview common screen sizes.
- Follow concrete milestones and next actions, with guided recovery that preserves completed work.
- Mark up screenshots, connect reference notes to completion requirements, and compare before-and-after evidence.
- Send tracked direction during an initiative. Active work finishes first; completed work stays intact, and fresh integrated QA is required before delivery. Direction receipts show received, incorporated, and verified revisions.
- Apply project delivery presets for pull requests, Coolify branch deployments, and Mac preview releases. Read-only preflight checks expose missing configuration; receipts distinguish Git updates from confirmed live deployments.
- Inspect shared files and dependencies across concurrent initiatives, and catch up with a digest of shipped work, decisions, and waiting items.
- Task drafts survive reopening, retries retain feedback request IDs, and incoming messages preserve your reading position.
- Retrying a cancelled mission resumes its previous stage and preserves completed subtasks. Only work cancelled with that mission is resumed.
- Project release preparation can adapt generated release notes to the project’s required changelog and release metadata format.
- Choose deployment per project: update the configured Git branch for Coolify auto-deploy, or use the Coolify API and health checks.
- Run project release workflows from an isolated worktree at the delivery commit, with version preparation before QA and published artifact verification before completion.
- Interrupted releases check existing artifacts before another publish; uncertain outcomes require reconciliation.
- Recovery buttons wrap inside narrow sidebars, keeping Retry, Restart fresh and Cancel task fully visible.
- QA now receives consistent read-only instructions. Missing tests and code fixes go back through a build teammate instead of being committed in a verification snapshot and blocking the mission.
- QA checks reviewer notes on completed subtasks as well as the goal, and preserves each acceptance criterion verbatim so its evidence matches the requirement.
- Drop screenshots and reference files into the Mac conversation, paste images, or use the paperclip. Preview and remove files before sending, including messages containing only files.
- The Lead reads your references and attaches relevant files to the tasks it creates or updates. Task references remain available to teammates and subtasks, independently of the original conversation.
- Up to 10 files per message, 20 MB per file and 60 MB total. Files stay in ThreadGrid’s data folder, outside your repository.
- Connect a GitHub repository directly without preparing a local checkout. New projects create private GitHub repositories by default.
- Every task gets its own branch and workspace from the freshly fetched base. Retries resume saved work; Restart fresh keeps the previous attempt for recovery.
- Review and QA run against separate snapshots of the exact commit. Changes invalidate earlier verification.
- Opening a pull request now waits for GitHub to confirm its merge. The merge commit is verified before release and deployment continue.
- Improved task coordination, progress reporting, account recovery, preview handling and completion evidence.
- A teammate picking a task back up can work again. When their earlier session had left a command running (a long build, say), every action on the retry was refused, and the task moved on to review with nothing done. The retry now runs normally.
- Teammates wait for their own long commands, like a signed build, before they report, instead of stopping early and losing the work when their session ends.
- A run that finishes without its result now counts as failed and is retried, instead of passing as done.
- Teammates can no longer type, click or take full-screen screenshots on your Mac while you're using it. One sent a keystroke and a click to the front window, during a call, while testing an app by hand. Hands-on checks of a native app now come to you as written steps. Browser previews and window-only screenshots of their own app still work.
- Work gets done much sooner. A check that hangs (a stuck test, say) now really stops at its time limit, instead of holding the whole goal for as long as the stuck program runs. One goal waited 95 minutes on a check with a 15-minute limit.
- When the teammate a task calls for is busy, an idle teammate in a related role picks it up (Full-stack covers Frontend, and so on), so parts of a goal no longer queue behind one person while the rest of the team waits.
- Fewer review rounds. The Code Reviewer can send work back for a serious issue once; after that, only something that really breaks it goes back, and anything else goes to QA as notes. Changes that only touch docs skip code review.
- Leaner plans. The Lead splits work into as few parts as its size allows, and no longer plans separate parts for specs, docs or test plans, or parts that need a person at the Mac. More requests stay a single task.
- Teammates know which parts of the goal are still being built by someone else, so they don't rebuild them or file tasks for them.
- Attach reference files to tasks: mockups, screenshots, PDFs, Word and text documents. Use the paperclip in the New task dialog, drop files on it, or paste a screenshot; add more from the task's panel, or drop them on it. Images show as thumbnails, and cards with files show a paperclip.
- Your team looks at them first: every teammate who works on the task, or on part of it, gets the files at the top of their instructions and opens them before starting (Word, RTF and ODT documents are also read as text). Codex teammates get the images attached directly.
- The files stay on your Mac, in ThreadGrid's folder, not in your repository, so nothing is committed or shipped by accident, and they're never uploaded to threadgrid.ai. Up to 20 MB a file.
- Quitting no longer logs an error when an account usage check was still finishing.
- Only real questions reach you. A teammate who can't start because another part of the goal hasn't landed yet now says so, and their task simply waits for that work and picks up again once it's merged ("Waiting for ONE-12, ONE-13" on the card). Before, that showed up in your Inbox as a decision that wasn't a question.
- A teammate who stops without asking anything and isn't waiting on anyone shows up as stuck, with what they found, so you can retry with a hint or cancel, instead of as "needs a decision".
- Updates reach you sooner. ThreadGrid now looks for a new version every 30 minutes, after your Mac wakes and whenever you bring it forward, even while its window is closed, and asks you to restart as soon as the new version has downloaded. With the window closed, a notification lets you know instead.
- Check for Updates… in the ThreadGrid menu and in the menu bar item. Once a new version is ready, it reads Restart to Update….
- If you pick Later, a banner keeps the offer at the top of the window, ThreadGrid asks again in a few hours, and quitting installs the update so the next launch is current.
- The real logos: Claude's spark and OpenAI's Codex mark, wherever ThreadGrid shows which agent does the work (AI accounts, the top bar, the team, each teammate's Runs on).
- AI accounts is calmer. Each account shows its name, status and usage; reordering, checking and removing appear when you point at it, and when it was last checked moves into a tooltip. Status lines are shorter and leave the numbers to the meters.
- Inbox: when several plans or ships are waiting, Approve all and Ship all do them in one go, after one confirmation. Sending something back is a Request changes button that opens the box where you need it, instead of an empty box under every card.
- Ships is a compact list grouped by day: what went out, how, and when, one line each.
- A task that hasn't started no longer shows a row of zeros, and an idea no longer says "Idea" twice. Team cards say 1 run, not 1 runs.
- Setting up a company never hides the way forward. Continue, Meet your Lead, Design my company and Hire the team stay on screen at any window size: if a step is taller than the window, its buttons stay pinned to the bottom while the rest scrolls.
- The Quick check fits on one screen: the checks sit in two columns, with the optional ones grouped under Optional. The welcome screen's artwork shrinks in short windows so Get started stays in view.
- Dialogs, like New task, are never taller than the window; what doesn't fit scrolls, and their buttons stay visible.
- The first-run screens mention Codex alongside Claude Code.
- Switching between accounts is steadier. An account that hits a limit on one model's weekly allowance now sits out until that limit resets, instead of being tried again (and notifying you) every few minutes. An account running past its limit on extra usage counts as full, so work moves on. The switch notes only appear when usage moved the work, not when ThreadGrid starts or when you reorder or switch accounts yourself.
- Adding an account: if the browser sign-in doesn't finish, Try again picks up the same account, and Dismiss clears it. Cancelling while ThreadGrid checks a finished sign-in no longer removes the account.
- If a teammate's agent has no account with usage left, their card says so ("Every Codex account is out of usage until 3:10 PM", or that a Codex account needs signing in), instead of waiting without a reason.
- Installing the Codex CLI while ThreadGrid is open: Check again in Settings → AI accounts now finds your Codex sign-in without a restart.
- What a Codex teammate is running reads cleanly on the board, without the shell's quoting around it. A teammate's effort reads X-high, not Xhigh.
- Run your team on more than one account. Add Claude accounts, and Codex accounts, in Settings → AI accounts; each one signs in through your browser. ThreadGrid uses them top to bottom: when the account in use passes 90% of its 5-hour or weekly limit (you choose the switch point), new work moves to the next account, and it comes back as soon as the first account's usage resets. A note tells you each time it switches. ThreadGrid reads each account's usage the way Claude Code's /usage does, which doesn't use any of it.
- Codex support. Any teammate can run on OpenAI's Codex CLI instead of Claude Code: pick it in their profile, or move the whole team at once from the Team page. Codex teammates work inside Codex's sandbox, so, like everyone else, they can't push, tag, switch branches or deploy; ThreadGrid commits their work and ships it after review and QA. If you like, when every account for one agent is out of usage, the team keeps going on the other.
- When every account is out, the team pauses and picks up again by itself at the earliest reset.
- A teammate who's stuck on a decision now always leaves the question in your Inbox.
- Privacy: the sign-ins for accounts you add are kept by Claude Code and Codex themselves, in your Mac's Keychain and in ThreadGrid's folder on your Mac. They never leave your Mac, and account names and emails aren't sent to threadgrid.ai. The privacy policy has the details.
- Setting up a company reads more clearly: each step shows as done once it's finished ("Silas read your codebase"), long steps no longer wrap under their icon, and an existing project says "Reading your project…".
- Meet your team: the list of people fades where there's more to scroll instead of cutting a row in half, and lines up with the choices below it. Hover a person's reason to read all of it.
- Your team from anywhere, if you want it. Sign in from Settings → Account (an email code, GitHub, Google or Apple), turn on Control from threadgrid.ai, and open threadgrid.ai/app on your phone or another computer: the same board, inbox and team, live. Approve plans and ships, answer questions, add work, pause or stop everything. An account is optional, and everything works without one, as before.
- The web can't run commands on your Mac, change check commands, open things on it or read secrets. Everything done from the web is marked in the activity log, and a Web badge shows while a browser is connected; you can disconnect it in Settings → Account.
- If you like, keep a company's board and team in your account (off by default, per company) to look in while your Mac is asleep. Code, diffs, agent transcripts, secrets and file paths never leave your Mac. The privacy policy has the details.
- A visual pass over the whole app: the border beam on the onboarding cards, tall onboarding steps in small windows, cards moving between columns, drag and drop, sheets that closed empty, the inbox, delete buttons that showed blue, and animations that froze on the first screen after launch. Animations respect Reduce Motion and pause while ThreadGrid is in the background.
- The engine checks every request more strictly, so a malformed or unexpected request can't change the wrong fields.
- ThreadGrid now needs macOS 13.3 or later; earlier versions of macOS 13 couldn't draw parts of the interface correctly.
- ThreadGrid now runs on Intel Macs. One download works on every Mac with macOS 13 or later, Apple silicon or Intel, and updates itself the same way.
- Quitting while your team is working asks first. Choose Quit When Done to let the current work finish (nothing new starts, then ThreadGrid quits by itself), Quit Now, or Cancel. The same goes for the Restart button after an update downloads. Pick a default in Settings → App → Quitting while the team works. Logging out or shutting down your Mac never waits.
- The Lead wears the brand blue.
- A finished run no longer shows "Working" for a moment after its result arrives.
- Coolify deploys work with current Coolify (4.3 and later). ThreadGrid now starts the deployment the way Coolify expects and waits for it to finish. Before, a ship could report a deployment as queued when Coolify never started one.
- If a check needs a tool that isn't installed on your Mac (a linter, say), that check is skipped with a note instead of failing every verification. Build and test checks still have to pass, and now name the missing program.
- ThreadGrid finds your Claude Code even if its startup check hasn't finished yet.
- The engine log no longer marks its normal startup line as an error.
- A new look: the ThreadGrid brand, with a new app icon, logo and menu bar icon, Navy and Midnight surfaces with Action Blue controls, and the Inter typeface.
- Approving several ships at once no longer trips over itself. Ships to the same repository now go out one at a time, and each one syncs with the latest base branch first. Before, two merges could run at the same moment and leave the base branch half-merged, which blocked every ship after it.
ThreadGrid 2.0 is a ground-up rebuild: an AI company for solo developers, running on the Claude Code already on your Mac. It replaces the 0.1 betas, which are no longer available; your data from them stays on your Mac, untouched.
- A board for everything you want built; the team triages, plans, builds in parallel git worktrees, reviews, verifies with QA and ships.
- Gated mode (you approve ideas, bigger plans and ships) or Full Autopilot with daily caps and self-pausing guardrails.
- Onboarding interviews you, then proposes a team for your project (from a Lead, PM, Architect, Designer, engineers, QA, Reviewer, DevOps and Growth) that you can change before hiring.
- Ship targets: merge + push, GitHub pull requests, release tags with changelog + GitHub Releases, and Coolify deploys with health checks.
- If you use the 21st.dev MCP with Claude Code, designers and frontend engineers use it to pull premium UI components into your product.
- Menu bar status, native notifications, a kill switch, usage by person/day/task, and opt-in, content-free crash reports.