What's new

Threads are sized by their code, and knowledge waits for the merge.

• File categories — each project sorts changed files into Code, Tests, Docs, Tooling and Derived; a thread is sized by its code, patterns support ! exclusions, and agents can fix the categories for you.
• Knowledge lands on merge — staged knowledge updates apply only when the thread merges, and grep_knowledge adds exact-text search over knowledge entries.
• Self-hosted GitLab — self-hosted GitLab instances sit beside gitlab.com, admitted per team; GitLab-backed first repositories, forks of read-only GitLab repos, and fast-forward merges.
• Overview first — the thread panel opens on Overview, with a live phone-width preview of the page the agent suggests, the threads started from this one, and follow-ups that start after merge.
• Review before merge — ship settings read in order (draft, review, auto-merge) and stay editable while queued; "Request changes" starts a fix turn, and the person who ships authors the pull request.
• Carmack review — runs as one message with sub-agent stages.
• Save prompts for later — bookmark your own messages in a thread as well as team-chat messages and agent replies.
• Diff viewer — download changed files, expand hidden context, attach files to line comments, and page through huge diffs.
• Darting Mono — the terminal uses Darting Mono, and transcripts get a purpose-built code font; Kimi K3.1 Pro and DeepSeek v4.1 Flash join the picker.

GitLab joins GitHub and Bitbucket, and the thread view gets a new shape.

• GitLab — connect, create, clone and push GitLab.com projects with a personal access token; merge requests ship through the merge queue, GitLab CI jobs report as checks and can be re-run, and GitLab projects can Go Live.
• Thread list column — the thread list sits in its own collapsible column beside the chat, with a filter menu in place of collapsible groups.
• Overview and Extras — the old Workspace dialog becomes the Extras tab of a collapsible, resizable side panel; team chat stays pinned open on wide screens.
• Snooze and blocked — snooze a thread until a chosen time or indefinitely, or mark it blocked by another thread; both fade in the list.
• Find and tidy threads — double-click a title to rename it, search threads by the keywords agents keep, a finished turn folds into one "Worked for…" row, and Summarize sits in the toolbar.
• Line comments — comment on lines of a thread's diff and send them with your next message; a broom button asks the agent to clean up the diff.
• Rewind only — Edit on user messages is gone; Rewind is the single way back. A queued message can Run now and end the running reply.
• One composer — threads and team chat share one message box, unsent drafts sync across devices, and you can answer an open question from it.
• Phone layout — on phones the thread's side panel is a right drawer opened from one header button.

A second git host, more ways to sign in, and shipping that lives in the composer.

• Bitbucket — create and connect Bitbucket Cloud projects with a repository access token; pushes, pull requests and Pipelines arrive by webhook, CI fixes read step logs, and Bitbucket projects can Go Live.
• Google and emailed-code sign-in — sign in with Google or a one-time emailed code alongside GitHub; linked provider emails reach the same account, and Security settings manage your sign-in methods.
• Ship status in the composer — the ship control above the message box names the next action or the thread's state, with review and auto-merge settings beside it; repos that require GitHub's merge queue land through it.
• Team chat in the side panel — a thread's team chat becomes the Chat tab of its right panel, and Conversations lists DMs and the thread chats you take part in.
• Saved messages — save team-chat messages and agent replies for later from the Saved page.
• Diff cards — agents show multi-file diff cards with notes pinned to lines, and changed files group into Code, Tests and Docs.
• Ready to build — an unbuilt plan leaves a "Ready to build" card at the end of the transcript, with a simpler plan header and Build controls.
• Thread list by age — threads group by last activity, shipped threads collapse under Completed, browser tabs show whether a thread is working or waiting on you, and New thread can start with a message.
• Per-member billing — each turn bills the member who sent it; Claude Haiku 5.5 and Mistral Large 4 join the lineup.

Single sign-on for companies, and Talk becomes the Coordinator.

• Enterprise SSO — sign in through Okta, Microsoft Entra or any OIDC provider, with Require SSO for a team, automatic team join, and GitHub linking for git work.
• The Coordinator — the project assistant is renamed from Talk to the Coordinator; it follows only the work it started, marked with a Watching pill, and Shipped and Knowledge move into panel tabs.
• Ship timeline — the whole ship flow folds into one collapsible timeline in the transcript, from the pull request to the merge, on one branch per thread.
• Dependency security — opt-in weekly audits of the default branch with offered fixes, an on-demand check, and a Dependency security tab in project settings.
• Project settings, reorganized — a status board, a Repository tab that shows where the code is hosted, a deployment survey, and Overview merged into General.
• Importing read-only repos — fork or copy a repository you can't push to into your own account when you import it.
• Recover failed deploys — a failed production deploy can be retried from its card or by the agent.
• Thread FYIs and @team — agents post FYIs to a thread's team chat, @thread asks a question there, and @team notifies everyone in a room.
• Faster setup — project setup finishes in about two minutes of agent time and reads "Setup done" when it files itself away.

A flat plan for Auto work, and every project opens on its own assistant.

• The $200 Auto plan — a subscription that funds Auto work through a 5-hour and a weekly window; stack units for more headroom, and see plan credit and prepaid credits as two separate balances.
• Project home — each project opens on a per-user project assistant (then called Talk) beside its Threads, Shipped history and Knowledgebase; from-scratch projects start there and it builds, publishes and files the work away.
• Smarter Auto routing — Auto picks tiers with a typed router, plans carry a build tier floor that Build honors, and a downgrade that would cost more than staying on the warm model is held.
• Cache-aware model switches — switching model asks before it throws away a thread's prompt cache and offers to compact the context first; per-message effort changes keep the cache warm.
• New models — GPT-6 Sol and Luna, Claude Opus 5.5 and Grok 4.7 join the picker, replacing their predecessors.
• Sandbox sizes — projects choose a sandbox size, and setup measures the app's peak memory.
• Icons for teams and projects — pick a colored emoji icon for any team or project in the sidebar.
• Plan cards read first — plans lead with a plain summary, engineering details fold away, a live "Writing the plan…" state shows while one streams, and mermaid diagrams open full screen.
• Team chat on touch — long-press a message for its actions, subthreads get their own links, and replies can be kept unread.

Slack-grade team chat, and a database for hosted apps.

• Threaded replies & DMs — Slack-style threads in team chat, reactions, edits and deletes, live typing presence, and direct messages from any avatar, name plaque, or @mention.
• Supabase for hosted apps — the sanctioned external backend when a Durable Object isn't enough: accounts, realtime, and relational data.
• Connect creates the repo — a repo-less project gets its GitHub repository created on connect, and a merged PR closes with a Published card.
• Two-card setup — Connect GitHub, then one Ship it that creates the repository and opens the PR.
• Settings Overview — project actions move to a settings Overview tab; merge queue and Connections live in settings too.
• Wake on preview — a preview link starts a missing sandbox instead of refusing.
• Media previews — attached screenshots preview the captured page, and transcript media paints as miniatures in the minimap.

Your team gets a place to talk, and your skills follow you everywhere.

• Team channels — dedicated channels in every shared team with a permanent #general, plus file and image attachments and emoji suggestions in the composer.
• Personal skills — import SKILL.md folders from your GitHub repos in chat; they follow you into every thread you send a turn in.
• GitHub access windows — lend your GitHub account for a single approved command against another repository, with a plain-language card saying what it does.
• Preview & Auth Doctors — setup checks flag a blocked preview or a sign-in wall and offer a doctor that fixes it with one PR.
• Resumable sub-agents — no step cap; a 15-minute clock is a checkpoint the lead can resume from.
• Rate-limit routing — a rate-limited turn parks and re-routes instead of failing.
• Worker limits — hosted workers honor compatibility_flags and CPU limits, and cron runs are bounded with one in flight per app.

A personal assistant above your projects, and a review gate on what agents do with your accounts.

• The Overseer — a per-user assistant thread outside teams and projects that summarizes what your delegates did and builds or ships on request.
• Action approval — a mutating request to a connected account or vaulted API parks the turn on a card showing exactly what would be sent; nothing runs until you approve.
• Sign-in handoff — an agent asks you to sign in to a site in the isolated browser; the session is saved so later visits load already signed in.
• Vaulted keys in deployed workers — vault items bind straight into hosted backends.
• Cold-baked snapshots — a project's recipe is proven from a fresh clone and saved as the snapshot every new thread boots from.
• Ready to ship, inline — the ship offer renders in the transcript, and the file viewer gains a Diff / Full file toggle.
• Sidebar sync — filter settings follow you across devices.

Agents use your credentials without ever seeing them.

• The vault — API keys and AWS credentials agents can use but never read; the sandbox egress injects them on requests to the provider's host. Project settings split into Env variables and a Secrets vault.
• Login browser — an isolated browser where agents sign in to websites with vaulted credentials, complete TOTP, and sign up for services through a project inbox.
• New composer — a rich editor with Slack-grade markdown blocks and push-to-talk voice input.
• Usage you can read — per-model stacked charts, spend by team member, and a per-project spend section.
• Team projects — any member can create projects in, or move projects into, their team; the Organizer opens to every project member.
• Terminal handoff — an agent hands the terminal to you when a prompt needs a password or a choice only you can make.
• Fresh setup — the lead runs setup from the clone scan and proves the recipe cold; GPT-6 Astra joins the model registry.

One button to publish, and the swarm reaches across your team.

• Ship it — a single composer button publishes a thread: opens the PR, watches CI, auto-fixes failures, and reports each stage as one-line events in the chat. Queue it while the agent is busy; pause and resume it.
• Docs ship like code — knowledge, rules, and plan writes stay pending in the thread and publish with Ship it.
• Ship Doctor — a first-time deploy requested in chat hands off to a dedicated doctor thread that collects secrets, deploys, and verifies.
• Cross-project threads — spawn threads and read knowledge across projects in the same team.
• Appearance — light and dark color schemes with preset themes.
• Instant desktop — the sandbox desktop starts at boot, so visual proof and UI driving begin immediately.
• Explicit deferrals — an agent must get your consent before any requested work is deferred to a follow-up plan.
• Deploy visibility — a sidebar spinner and thread banners while your merge is deploying, tracked by webhook.

The swarm ships to production.

• Deploy to darting.app — build once and serve always-on at https://<slug>.darting.app, with a slug you choose and an availability check as you type. Every deployable merge to main goes live.
• Worker backends — an app directory with worker/ deploys a Workers backend behind /api/* beside the static frontend, with Durable Objects, cron triggers, and production secrets.
• Deployment settings — per-app deployment cards with status, progress, build logs, branch drift, and the deployed commit; a PR gains a "Live" stage once its code is detected in production.
• Ask Carmack — a one-click brutal code review from the composer.
• Doctor threads — a preview blocked by framing policy or a deploy that stopped tracking spawns a dedicated fix thread that diagnoses, repairs, and ships one PR.
• Setup redesign — a feed-centered setup thread that classifies app kinds and proves each recipe before handing off.

Human conversation gets its own rail, and Atlas gets a new name.

• Team chat — a collapsible rail on every thread for talking to teammates, with @mentions, unread counts on the thread list, and mention badges in the project switcher, kept out of the agent transcript.
• Knowledgebase — Atlas becomes the Knowledgebase, with a dedicated Plans section, pinch-to-zoom on the graph, and keys that follow entry titles.
• Ship it mode — a default one-button Ship it panel, with an Expert toggle for the full pipeline.
• Unified settings — global settings move into one sidebar with Credits and Teams; rules and knowledge sources get their own tab.
• Word-level diffs — inline highlighting in the commit diff view, and full file paths in tool headers.
• Restore last thread — opening a project returns you to where you left off.

See the swarm work, and let it make media.

• Sub-agent navigation — breadcrumb trails, a docked agent graph in the side panel, and a deep link for every sub-agent.
• Split model selection — pick one model for the lead and another for its sub-agents; spawns queue at the concurrency limit instead of failing, and Auto routes each spawn by its declared tier.
• Video generation — MiniMax H3 clips with first/last frames, reference media, and native audio, gated behind a media-craft skill library agents must read before a paid render.
• UI diagnosis — a driver agent reproduces a defect in a real browser when the code alone can't answer what happens on screen.
• Tag a teammate — a +person button pings someone on a thread without sending the agent a message, and a Waiting group in the sidebar tracks who hasn't replied.
• Rename threads and projects — from the sidebar, the top bar, or Project Settings; a manual name is pinned so the model won't overwrite it.

Working together, and picking a model without thinking about it.

• Team roles & invites — owners, managers, and members with self-service promotion and ownership transfer; invite by email with recoverable links.
• Fork any message — branch a conversation from any point, with copy and branch actions on every message.
• Model tiers — Intelligence / Balance / Cost pick the model for you, with an Advanced picker and per-model zero-data-retention badges when you want control.
• Per-model spend caps — enable or disable models per project and set hourly or daily limits.
• Shareable preview links — a link to a thread's running app wakes a paused sandbox on open, with a keep-awake countdown in the preview.
• @plan in the composer — mention a plan by key to attach it to a thread, and build it straight from the plan modal.
• Identity-only GitHub sign-in — sign in first, grant repository access only when a project needs it.

The command center is now the Product Map — and the swarm ships through a smarter pipeline.

• Project Map — shipped PRs, in-flight threads, and proposed plans across every product area, with one-click Build on plans that are ready.
• Merge queue — groups open PRs by file overlap so unrelated work lands in parallel; auto-merge only after you arm it.
• Living plans — versioned plan documents with staleness checks as main moves; no Ask/Plan/Agent mode picker — the lead agent self-assesses complexity.
• Subscriptions — Free / Pro / Pro+ / Ultra with included agent usage and sandbox hours; pay-as-you-go and spend caps on paid plans.
• Model lineup — Claude Fable 5, Opus 4.8, Sonnet 5, GLM 5.2, Grok 4.5, and GPT-5.6 Sol / Terra / Luna.
• GitHub App auth — sign in, then choose which repos the app can access.
• Guided onboarding — first-run flow for importing a repo or starting fresh; projects can exist before a repo is connected.
• Shareable links — thread and document URLs get proper social previews when shared.

Reviewing and shipping agent work is now first-class.

• SVG branch graph in the Git tab — every thread and automation gets its own lane, with clickable commits that open an inline diff.
• Commit Thread — merge a thread into a feature branch and open a pull request with an LLM-drafted title and body.
• View in IDE — fetch any agent's branch locally and review it in your editor's native diff.
• Post-merge banner now surfaces CI checks and PR status.

Agents got a memory and a way to react to events.

• Knowledge base — a materialized store of architecture, conventions, and decisions, written and kept current by background agents.
• Automatic context — agents load the project knowledge a task needs instead of you pasting it into every new chat.
• Configurable automations — trigger post-processing agents on tool calls, events, or a schedule, with per-project enable/disable and prompt overrides.
• Streaming clone progress during project setup.

The first public cut of darting.dev.

• Chat with a persistent lead agent that builds, plans, and delegates.
• Isolated E2B sandboxes for every thread, branched from main.
• Multiple threads per project, each on its own git branch.
• Real-time streaming over WebSocket with crash recovery.
• Unified New Project dialog: Git URL, start fresh, or empty repo.