What Grain shipped.

Release availability: web, desktop, mobile, and database setup

This update distinguishes live web improvements from other rollout stages. The public Mac build is 1.1.93. New iOS document editing, voice-to-task, publishing, and Live Activities remain in internal TestFlight. Supabase and MongoDB setup, further Executor recovery, and hosted exact-source build verification are not being announced as live.

• Supabase native authorization still needs Grain’s registered integration configuration
• MongoDB requires a private backend or Executor; database credentials do not belong in static site code
• Generated schema files do not mean a database has been provisioned or connected
• The earlier database article now includes a dated availability clarification

Request changes now revises the plan

Request Changes during plan review now does what it says: Grain sends your note back through planning, returns a revised plan, and asks for approval again. It no longer treats the feedback as approval and starts building the previous plan.

• Each revision returns a fresh plan and a fresh approval checkpoint
• The planning loop is bounded at three rounds so a task cannot wait forever
• The first plan is unchanged for teams that approve it immediately

A second subscription is finally extra capacity

If one of your plan accounts hits its rate limit, Grain now continues on another account of the same plan instead of switching to a different vendor. Previously limits were tracked per provider, so a second Claude Max subscription bought you a manual switch in Settings and nothing else — the work moved to Codex or Grok while an idle account sat unused.

• A rate limit moves to your next account on the same plan, and only changes provider once every account of that plan is limited
• Repeated limits walk the whole list rather than bouncing between the first two accounts
• Gemini and Kimi support multiple accounts too, alongside Claude, Codex and Grok
• Muse Code is now a managed plan: add accounts and see its sign-in state
• A signed-out Grok or Kimi finally raises the re-auth banner — both were checked but never reported, so an expired login just failed tasks quietly

See every connected plan, live

Settings now shows the real state of every plan account you have connected: which one is in use, which is at its limit and when it frees up, which needs signing in again, and how many Grain Models credits remain. It also lists the model each AI teammate uses.

• Per-account limits with the time until they reset, reported by your own machine
• A teammate using the workspace default model is labelled as inheriting it, so changing that default never silently changes what a teammate appears to use
• A workspace with no machine reporting says so, rather than claiming everything is healthy

Assignment emails, and a visible history on every task

Assigning a task to someone now emails them. Every task also carries a visible history of who created it, who assigned it, who moved it and when — with people and agents shown as distinct actors rather than blurred into one.

• No email when you assign a task to yourself, and no duplicate if you re-save without changing the owner
• The assignment still lands if mail cannot be sent — the notification never blocks the work
• History distinguishes a person from an agent, a cron run or an executor

Generated apps get a database, and a modern project

How generated interfaces and data layers fit together. Availability note: a configured database runtime is required; general one-click database connections are not yet live.

• Generated schema files do not mean a database has been provisioned or connected
• Supabase projects ship their schema as real SQL with row level security, so anyone who clones the repo can reproduce it
• The app renders before you fill in credentials, with an empty state instead of a blank page
• Web projects now use Tailwind with a real config and design tokens, not hand-written CSS you would have to replace

Grain Sheets and Grain Docs stay editable inside every task

The built-in Office surfaces now use Grain product names and behave like part of the task instead of a separate app. Spreadsheets open in Grain Sheets, documents open in Grain Docs, and the shared action is Open in Grain Suite. The workbook surface has one clear header, preserves in-progress edits when you move between tasks, and exposes the save, download, and close actions users expect.

• Spreadsheet cards say Grain Sheets · editable · save and export
• Document cards say Grain Docs · editable · export to Word or PDF
• Open in Grain Suite replaces the old Gen Office wording everywhere users see it
• Workbook edits save before task navigation and Cmd/Ctrl+S saves immediately
• Download workbook copy and Close workbook are functional actions in the editor
• Desktop 1.1.63 is live for notarized Mac, Windows NSIS, Linux deb and Linux rpm

Uploaded CSVs open as data, not a blank document

A task such as “help me fill out the ESG reporting” could ignore its uploaded CSV and return a generic Markdown worksheet. The server-side fallback was routing from the task title without enough attachment context, and the local executor used a narrower set of edit verbs. Grain now carries the attached Office filename and type into routing, recognizes fill, complete and populate as edit actions, and sends consented CSV data to the hosted sheet editor while preserving the original file as the task artifact.

• Consented CSV and TSV uploads route to the hosted data editor and save back with their original filename
• XLS, XLSX, ODS, DOCX, Markdown and text files use the same explicit Grain Models attachment consent flow
• Local Mac, Windows and Linux executors apply the same Office-file routing contract as Grain Models
• Image and PDF attachments do not get mistaken for spreadsheets just because a task mentions a report
• The exact ESG-plus-CSV failure now has cloud, local-executor and browser regression coverage
• Desktop 1.1.58 is live for notarized Mac, Windows NSIS, Linux deb and Linux rpm

Local agents keep their work out of your checkout

A local task now refuses to run inside the checkout you are actively developing in and prepares its own isolated task workspace instead. That keeps an agent run from colliding with your branch, staged files, or uncommitted changes. Planned runs are also told the real isolated directory they are executing in, so every phase edits the intended workspace. We also tightened transient UI cleanup so leaving Skills while an install, uninstall, bundle install, or catalog sync is finishing cannot update a page that has already closed.

• Local executor tasks use an isolated checkout instead of writing into the developer's active working tree
• Every phase of a planned run receives the actual isolated workspace path
• Shared-checkout refusal is covered by 17 dedicated safety tests across the supported repository paths
• Skill install, uninstall, bundle and sync timers are cancelled when the page unmounts
• Desktop 1.1.57 is live for notarized Mac, Windows NSIS, Linux deb and Linux rpm
• All public 1.1.57 installers were downloaded after upload and verified byte-for-byte against their release builds

Your spreadsheet or document stays inside the task

Upload a CSV, Excel workbook, or Word document in task chat and it now appears as a real file card — not an invisible attachment and not a generated landing page. Open it, inspect the actual sheets or document, edit it, save it back to the task, and ask Grain for another change in the same conversation. The workflow runs in the browser and the Mac, Windows, Linux, iPhone, and iPad apps. We also fixed the executor lock that could leave a local edit saying locked_by_other for ten minutes even though the selected machine was idle.

• CSV, TSV, XLS, XLSX and ODS open as editable sheets; DOCX, Markdown and text open as editable documents
• Uploaded inputs and produced files remain visible as named cards in Preview and Chat
• Save updates the task file; Ask Grain to edit keeps the same task, project, device and conversation
• Grain Models handles cloud edits, while local tasks continue on the selected Mac, Windows or Linux executor
• Native iPhone and iPad support ships in Grain 1.1.8 build 60, now valid in TestFlight
• Desktop 1.1.54 is live for notarized Mac, Windows NSIS, Linux deb and Linux rpm

Planned tasks remember what they learned

A task routed through plan → implement → verify was running with no memory at all. The pipeline builds its own prompts for each phase, and those prompts never carried recalled memories, auto-discovered skills, or the map of the other repos in a multi-repo task — while the identical task run in a single pass got all three. Nothing failed, so the only symptom was an agent repeating a mistake it had already been taught, on exactly the tasks complex enough to be worth planning. Separately, agents running on an API model can now use your connected MCP servers.

• Planned runs carry recalled memory, discovered skills and the multi-repo workspace map into every phase
• Company Brain and your other MCP connectors now work on API-model runs, not only on the Claude Code path
• The file-listing tool’s own documented pattern (**/*.ts) actually matches files now — it never had
• Cloud API runs use the same execution rules as every other backend instead of a quietly different set

Mix your stacks: Claude Code plans, OpenRouter implements

You can now run one backend as your main engine and hand a single phase to a different provider entirely — Claude Code plans the work, OpenRouter (or Groq, DeepSeek, Together, xAI, Fireworks, MiniMax) implements or verifies it. Previously the only non-Anthropic option for a phase was another local CLI, because Grain’s cloud path spoke Anthropic’s API and nothing else. Pick “OpenRouter (API key)” for any phase in Settings → Execution, or per computer.

• Any OpenAI-compatible provider can run the plan, implement or verify phase
• Model ids pass through verbatim, so anything in OpenRouter’s catalogue works
• The phase uses that provider’s own API key — your Claude Code subscription keeps handling the phases you leave on it
• Tool calls, file edits and commands behave the same whichever provider runs the phase

Fix a half-connected account, and give a task more than one repo

If you started connecting a second CLI account and did not finish the sign-in, the account was stuck: no way to complete it, no way to remove it, and switching to it pointed every task at a signed-out login with no clue why. Each account row now says whether it is actually signed in, offers “Sign in” to finish or redo the login, and “Remove” to delete it — and Grain refuses to switch to an account whose sign-in never completed instead of failing silently. Separately, a task can now name more than one repository, and Plans & usage has been rebuilt on Grain’s own design system.

• Every CLI account row shows its real sign-in state, checked per account rather than assumed
• “Sign in” finishes or redoes an account’s login; “Remove” deletes it (the default account can’t be removed)
• Switching to an account that isn’t signed in is refused, with the fix named — no more silent task failures
• A task can span repos: pick a primary (where the agent runs) plus any others it may read and edit, and swap which is primary
• Plans & usage rebuilt in the cream-and-ink design system, with the usage sparkline drawn from your real spend

Two subscriptions, one machine — and rooms answer on your own computer

Got a personal Claude Max and a work one? Connect both. Settings → AI & Models now manages multiple accounts per CLI provider — Claude Code, Codex and Grok — each signed into its own profile, switchable per computer with one click. Room agents no longer need a cloud API key either: with the desktop app running, an @mention is answered by your own computer on your own subscription, the same free path Ask AI uses — and private rooms deliberately stay off that path unless you pin them to a specific machine. Say “daily …” in a room and Grain hears the schedule, not just the sentence. Settings itself has been rebuilt around a grouped, searchable rail with a proper Plans & usage page; everything that cluttered the sidebar now lives inside it, and old links still work.

• Multiple accounts per CLI provider: add “work” next to “personal” for Claude Code, Codex or Grok, and switch per computer
• Adding an account opens Terminal with the exact sign-in command, pointed at that account’s own config home
• Rooms without a cloud key answer through your connected computer instead of refusing — and say so honestly when the run fails
• Private rooms never ship their transcript to an arbitrary computer; pin one to a specific machine to allow it
• “@agent daily research …” creates a real daily automation — questions that merely contain “daily” don’t
• Ask AI finally shows your conversation history — always saved, never listed; your chats are yours alone now, too
• Deleting a task (or a draft) from the Mac app works again — confirm dialogs were silently answering “no” on desktop
• Settings: grouped, searchable navigation with a new Plans & usage page showing live credit usage; plan changes are admin-only, enforced server-side
• Hire Agent is a searchable catalog with each template’s skills, department and level up front

Drafts grow up, and memory learns team manners

The draft switcher now tells you where every draft stands without opening anything: an amber dot for conflicts, an up-arrow when your main branch has moved ahead, and a blue dot on drafts with edits you have not looked at yet — each person gets their own. Accepted drafts stay in the menu as browsable history. When updating a draft from main hits conflicts, Grain now queues the agent to rework the draft in its own checkout instead of leaving you a toast. Memory, meanwhile, learns to behave on a team.

• Draft pill: conflicts, updates-from-main and unviewed edits at a glance
• Accepted drafts remain in the switcher as read-only history
• A conflicted Update becomes an agent task: resolve the conflicts in the draft, keep both sides’ intent, never push
• Draft previews get their own ports and never crowd out your main preview
• “Just for me” memories: recalled only for your own work, invisible to teammates
• Memory writes respect room membership and repo access, and org-wide forgetting needs an admin
• Rejecting an agent’s work with a note is now remembered — the same mistake stops repeating
• A fact you typed into Memory is never auto-deleted for being “unused”

The Mac app has a place to name your computer again

Renaming a computer has always lived on the Devices page, but the native Mac app had no signpost pointing at it. There is now a "Name This Computer…" item in the app menu (⌘,) that jumps straight there.

• ⌘, from anywhere in the app opens Devices
• Renaming itself is unchanged — click a device’s name, or the "Rename" button beside it

Ask your own data a question, in plain English

Your admin connects your warehouse, your search cluster, an internal API, or the tools you already use — once, with a read-only login — and everyone on the team can then ask questions of them in Ask AI. No database account, no SQL, and nobody but the admin ever sees the credential. Ask "how many trials converted last week" and Grain writes the query, runs it, and shows you exactly what it ran so you can check the answer instead of trusting it.

• PostgreSQL, Elasticsearch, or any read-only internal API
• Your connected tools too — Notion, HubSpot, Linear, or your own server via URL and token; Ask AI picks whichever fits the question
• Set up once by an admin; share each source with the whole workspace or with named roles
• Read-only is enforced, not just asked for: Postgres runs inside a read-only transaction, and admins tick exactly which tools Ask AI may call
• Scope a source to particular schemas or indexes, and every query is checked against that
• Watch it work — Ask AI names the source it is querying while it queries it
• Every answer shows the query behind it, and says so plainly when one could not run
• Admins see a full log of everything asked, including anything that was refused

Drafts: try an idea without touching your main code

A draft is a named parallel copy of your project. Ask for a change inside a draft and the work happens in its own checkout on its own branch — your main working tree is never touched. Each draft keeps its own conversation, its own preview and its own history, so you can run two ideas side by side and compare them. When one is right, Accept merges it into your main branch locally; when it is not, delete it and nothing is left behind. A draft you never put anything into cleans itself up after 24 hours; one with work in it is kept.

• Every draft gets its own branch, checkout, chat and live preview
• Accept merges the draft into your main branch on your own machine — nothing is ever pushed for you
• Update pulls newer main commits into a draft, so you can catch up without starting over
• Grain refuses rather than tidying up after you: a merge onto a branch with uncommitted changes is declined with the reason, never stashed automatically
• Deleting a draft keeps its branch if it still holds unmerged commits
• Drafts are named from your first message, and stay out of your task board

Effort now asks each model what it supports, instead of guessing

The Effort control shipped yesterday worked out what each model could do from its name. That guessed wrong on the newest models — it thought Claude Haiku 4.5 could not reason, and it sent the older 'thinking budget' setting to Opus 5 and Fable 5, which take a simpler effort level instead. Grain now reads a live catalogue of model capabilities, so it only ever sends a model a setting that model actually accepts, and sends nothing at all when it does not recognise one.

• Model capabilities come from a maintained catalogue, not from pattern-matching names
• Reasoning depth is sent in whatever form each model accepts, using that model's own levels
• A model Grain does not recognise gets no reasoning setting rather than a rejected one
• Thinking budgets are capped to each model's declared maximum
• The OpenRouter stealth model is listed under its real id

One Effort dial for every model, and OpenRouter goes live

A single Effort control — Light to Ultracode — now sets how hard the model thinks, and it maps to each provider's own reasoning knob: extended thinking on Claude, reasoning effort on OpenAI and the codex CLI. Pick it once per task and it reaches whichever model runs. OpenRouter is now a first-class provider too: paste a key in Settings and route to anything it offers, including the stealth ox-alpha model.

• Effort: Light, Standard, High, Ultracode — one setting, mapped to each provider natively
• Models without a reasoning knob are left alone rather than sent a parameter they would reject
• OpenRouter: paste an API key and pick a model, including the stealth ox-alpha
• Ask AI composer stays pinned to the bottom, with a live line showing which computer a hand-off runs on
• The preview pane can open any running server in your real browser

Your git push policy follows the task, and your phone can see a preview

The rule for whether a finished task pushes and opens a pull request now comes from that task's own workspace, so a policy you set is honoured on every machine — including an executor signed in with a shared secret, which previously could not read it. Every push and commit outcome is now reported honestly: held, pushed, or failed, and where the work landed. And your phone can finally ask to see a running dev server, not just receive one.

• Push / pull-request policy resolves from the task's organization, never a global guess
• Honest reporting on every outcome — a failed push no longer looks like a clean one
• iOS and iPad can request a live preview of a running server
• Adopted dev servers stop being reported "stopped" while they are still running

A security fix in how commits are made

Task titles were being placed on a shell command line when a commit was made, which meant a crafted title could run a command. That is closed — commits and pushes now pass their arguments directly, with no shell in between. Alongside it, the preview stops declaring your dev server dead while it is still running, and adds a reliable "open in your browser" for servers it cannot embed.

• Commit and push arguments never touch a shell — a task title cannot run code
• A failed commit or push is reported instead of dropping the work in silence
• The preview no longer marks a running dev server as stopped
• Open any running server in your real browser from the preview pane

Ask AI actually reads your connected data, and briefs stop opening empty

Ask AI now genuinely reads your connected sources instead of sounding like it did: the query planner reaches your key even on a local-first setup, the knowledge base stops being silently dropped from the prompt, and a citation only appears for a document the model truly saw. Briefs that were opening blank — and saving that blankness over your work — are fixed.

• Company Brain runs on local-first setups, not only when a cloud key is set
• Citations name only documents the model was actually given
• Briefs open with their real content and no longer overwrite it on save
• When a source cannot be read, Ask AI says so instead of guessing

The task preview becomes a real, browsable browser

When an agent starts a dev server, the Preview tab now loads the actual running app in a real browser with a working address bar — not a screenshot and not a mock. Click through routes, watch the console, pick elements to comment on, and mirror it to your phone. Grain discovers a server the agent started on its own and adopts it, so you never have to wire anything up.

• The running app, embedded live, with a real address bar and back/forward
• Element picker, console and comments on top of the running page
• Grain finds and adopts a dev server the agent started by itself
• Mirror the server to your phone or any device with one click

Tabs, a unified Ask, and the Lovable task workspace

Open several tasks and rooms as tabs and move between them freely. The task workspace was rebuilt into a two-pane layout — the conversation on the left, a live Preview / Deliverable / Code / Details pane on the right — so reviewing an agent's work never means losing the thread. Ask is unified across your workspace, and remote control lets you drive an executor from anywhere.

• Workspace tabs for tasks and rooms
• Two-pane task workspace: conversation beside a live deliverable
• A single Ask across your whole workspace
• Elasticsearch auto-bridges as a Company Brain source, no manual wiring

Company Brain on the local / free path, and a real in-app updater

Company Brain now works through the desktop app on the free, local-first path — your connected data reachable without a cloud key. The desktop app updates itself in place instead of asking you to re-download, and a batch of executor authentication and environment fixes make runs start more reliably.

• Company Brain over the local executor, no cloud key required
• In-place desktop auto-update
• Executor environment and sign-in fixes for more reliable runs
• Covers releases 1.1.13 through 1.1.26

A cleaner Connectors page, and safer sharing across your team

Connectors got the redesign it was missing: a category rail on the left and one clean, searchable list on the right, each connector showing what it does at a glance. Adding your own MCP server is one dialog now — name, URL and token. Under the hood, several sharing and permission edges were tightened so removing or demoting a teammate does exactly what it says.

• Connectors: browse by category, search once, see every tool in one list
• Add a custom MCP server — URL and API token — from a single dialog
• Removing a teammate works even after they have opened another workspace
• Demoting a teammate now actually reduces what they can reach
• A wrong password and a signed-out coding tool each say what to do, in plain language
• macOS is on 1.1.12; Windows and Linux builds follow shortly

Company Brain, on the desktop app

The desktop app carries the web app inside it, so 1.1.10 was built before Company Brain existed and could not show it. This build brings the whole of it to the Mac, Windows and Linux apps: your connected databases and tools, the tool picker, and Ask AI telling you which source it is querying while it queries it.

• Ask your own databases and connected tools from Ask AI, on the desktop app
• Admins pick exactly which tools Ask AI may call, per server
• Add a custom MCP server with a URL and an API token, from one dialog
• Ask AI names the source it is working through, rather than showing a spinner

A wrong password now says so, instead of blaming the server

If you mistyped your password, the sign-in screen told you Grain was having a server problem. Nothing was wrong with the server — the real message was being replaced before it reached the page, so the one thing you could actually fix was the one thing it never said. Windows and Linux are on this version too, so every platform is back on the same build.

• Sign in with the wrong password and you are told exactly that
• A real outage still reads as an outage, so the two stay distinguishable
• Windows, Linux and macOS all on 1.1.10

Open a preview on your phone, and hand work to people as easily as to agents

A preview used to live on one machine — it ran on localhost, so only you could see it. Now Grain can give it a private address you can open on a phone or tablet, so you can check a layout on the device it was designed for. Tasks also stop being agent-only: assign one to a person, filter the board by who owns it or by tag, and leave a note that your team reads and the agent never acts on.

• Open a running preview on your phone — scan the code, or send the link to whoever needs to look
• On iPhone and iPad, tap any element in the live app to ask the agent about it
• Assign a task to a person, not just an agent — Grain leaves it alone and waits for them
• Filter the board by person, agent or tag, on desktop and on mobile
• Leave a note on a task: your team sees it, the agent never reads it as an instruction
• When a coding tool on your machine is not signed in, the task now says so and names the fix

Point at the running app and tell the agent what to change

When a task builds something you can run, Grain already showed you a picture of it. Now you can click it. Hover to outline any element, click to select it, and Grain hands the agent exactly what it needs — the element, where it sits, and the styles actually applied to it — so you can say "make this bigger" instead of describing which button you meant.

• Click any element in the preview to select it — no dev tools, no copying selectors by hand
• The selected element goes into the chat with its styles, ready for you to say what to change
• Grain fills in the part it knows and leaves the request to you — nothing is sent on your behalf
• Works on the screenshot of your own local server, which never leaves your machine

Windows and Linux catch up, stuck work frees itself, and plan review finally shows up

Every platform is on the same version for the first time — Windows and Linux had been months behind while releases went out looking healthy. A task can no longer sit in progress forever because the machine that claimed it never came back. And step-by-step plan review, which quietly never appeared on real plans, now does.

• Windows and Linux builds are current again — installers for both ship with every release
• Work claimed by a machine that goes away is released automatically instead of waiting forever
• The fleet view shows a stalled agent as stalled, rather than a spinner that never resolves
• Removed the progress bar that filled up on a timer and told you nothing
• Fixed: plan review offered no way to pick individual steps on most plans — the checkboxes, per-step notes and questions were there but never rendered
• Fixed: approving some steps of a plan could silently approve a step you had not chosen

Assign work to people, agents that carry context, and a calmer app

Tasks can now be assigned to a person, not just an agent — a human-owned task waits for them and is never picked up by the executor. When work changes hands, what was learned doing it goes with it. Plans can be approved step by step, with a note on any step. The run view shows the real steps an agent takes, the left nav collapses, and your Mac stays one device in the fleet.

• Assign a task to a teammate or an agent, and hand it back and forth with one audit trail
• Handoffs carry context — the next owner starts with what the last one learned
• Approve a plan step by step, add a note to any step, or send it back with questions
• Run view shows each tool call and file touched, not an undifferentiated log
• Collapsible sidebar (⌘\) and quieter counts — a number now means something needs you
• Workrooms rebuilt: one list of conversations, full height, agents with their own faces
• Your Mac stays one device instead of reappearing as a new one
• Fixed: tasks in the bidding state were missing from the board entirely
• Fixed: an approved plan could be overwritten by the approval note itself
• Fixed: the Skills page failed to load; copy and paste in the desktop app

Connecting an integration actually works now

Connecting Linear, Slack or any other OAuth integration failed with “Authentication required”. The authorize endpoint expected a browser session cookie that Grain has never used — sessions live in local storage and travel as a header, which a pop-up window does not carry. Every provider was affected, not just the one you happened to try.

• OAuth connect flows now mint their authorization server-side before the pop-up opens
• The workspace a connection belongs to is still resolved on the server and cannot be set by the client
• Desktop app tolerates running ahead of the backend during a rolling deploy instead of dead-ending
• A stale browser tab no longer shows an error page after a deploy — it refreshes itself once and carries on
• Mac 0.7.80 notarized; Grain Mobile build 46 on TestFlight

Plan the work, not just the agents

Grain now carries the whole shape of delivery work: Projects with a lead, a target date and self-reported health; Cycles per team; issues with keys, estimates, labels and a named human reviewer. Rooms become Teams by taking a key, so ENG-142 means something. Agents get the missing half too — a system catalog of who owns what, what depends on it, and which decisions constrain it, injected into every run.

• Projects: lead, target date, health, and progress computed from real issue status
• Cycles per team, with rollover of unfinished work
• Issues get keys (ENG-142), estimates, labels, sub-issues, and a human reviewer separate from the agent doing the work
• A Room becomes a Team by taking a key — no second place to manage people
• Private teams stay private: projects, issues and labels scoped to a room you are not in are invisible, not merely hidden
• System catalog: components, ownership, dependencies and decision records
• Agents are told who owns the code they are changing, what breaks if they change it, and which past decisions still stand
• Import from Linear: teams, projects, cycles, labels and issues — run it twice, nothing duplicates
• Bitbucket pull requests actually work: app-password auth, expiring tokens refreshed, and the repo’s real default branch instead of an assumed "main"
• Apps boards get drag-and-drop and inline rename
• Mac 0.7.79: Cmd-Q no longer hangs, and the updater stopped announcing itself on every launch
• Windows and Linux installers building again after a toolchain break

Skills from GitHub, command policies, and shared Apps

Import any agent skill straight from GitHub and promote it to your org catalog with admin approval. Admins can predeclare allow/deny rules over what agents may run — a deny wins even in full-autonomy mode. A new Apps tab adds live shared trackers, checklists, forms, and boards your agents can build for you. Agent memory now scopes to the Room it was learned in.

• Skills → Import: paste owner/repo or a GitHub URL; imports land as your private skills
• Promote a skill to the org catalog — admins approve or reject from Approvals
• Command Policy: org-wide + per-agent allow/deny rules (exact, prefix, glob, regex) over commands and tools
• Deny rules are enforced before execution — desktop CLI, cloud tool loop, and browser automation; every decision is logged
• Apps: role-gated trackers, checklists, forms, and Kanban boards — live-updating for the whole team
• Ask AI or any agent can create and fill Apps ("make a launch checklist…")
• Room-scoped agent memory: recall prefers the room a memory came from, and stops leaking across rooms
• Mac desktop 0.7.75 notarized, with in-app auto-update from 0.7.74

Workrooms bring people, agents, and machines into one room

Workrooms are now a top-level Grain experience across web and iPad. The room roster shows people, agents, and the machines doing the work, while one unified feed keeps human messages, agent progress, approvals, and results in a single timeline.

• Agents appear beside People as visible room members on the web
• iOS room rosters show agents and execution machines with their current status
• Human messages, agent output, approvals, and results render in one unified feed
• Workrooms move into the main iOS navigation with a Slack-shaped iPad layout
• Ten issues from an adversarial iPad review are fixed across layout, navigation, and interaction
• Grain Mobile build 42 uploaded to TestFlight

Claude Opus 5 is live across Grain

Grain now supports Anthropic’s Claude Opus 5 everywhere models are selected or routed. Opus 5 is the recommended live Opus tier for agent configuration, planning, verification, quality-first routing, escalation, and cost tracking; Opus 4.8 remains available for existing configurations.

• Claude Opus 5 in Claude Max, Claude API, Grain Cloud, and OpenRouter model selectors
• Planning and verification recipes now route current Opus work to claude-opus-5
• Quality-first presets, escalations, and new orchestrator agents use Opus 5
• Accurate $5 / $25 per-million-token pricing and cache-cost tracking
• Fresh 0.7.73 installers for notarized macOS, Windows, Debian/Ubuntu, AppImage, and RPM
• Claude Opus 4.8 remains selectable for backward compatibility

Finished work is clearer — and agents know when they need you

Grain now separates finished deliverables from the activity that produced them, surfaces blocked decisions as Needs you, and applies clearer autonomy policies to agent runs. The release also rolls up the latest provider onboarding, Kimi detection, project discovery, and sign-in reliability fixes.

• Deliverables get a dedicated result surface with cleaner summaries and file links
• Needs you collects approvals, questions, and blocked decisions without burying them in activity
• Agent policies make approval and execution boundaries easier to understand
• Provider setup covers the full coding-backend and model catalog, including Kimi Code
• Discover can add unmatched local repositories as projects in one click
• OAuth redirects and task routing are more reliable
• Fresh 0.7.72 installers for Windows and Linux, matching the notarized Mac release

This Mac only actually filters to this machine

Projects no longer uses the org’s last-heartbeating executor as “this Mac” (that flipped between machines). Identity comes from this install’s clientId; This Mac only only lists folders registered on that id. Link folder / Clone here still attach the same Bitbucket remote on another disk.

• Local device identity from ~/.grain/config.json (not org executorClientId)
• Strict This Mac only — no unscoped paths from other machines
• Mac 0.7.51 on download.grain.sh

Multi-Mac projects: same Bitbucket remote, unique folder per machine

Studio and laptop can both connect to the same org and git remotes while each keeps its own local checkout path. Link folder / Clone here on the second machine. Mac 0.7.50 notarized on download.grain.sh (MinIO CDN).

• Mac desktop 0.7.50 notarized + auto-update on download.grain.sh
• Per-machine devicePaths
• Import merges by Bitbucket/GitHub remote across Macs

Grok CLI detection, multi-Mac project paths, Workrooms control plane

Desktop finds the official Grok Build install at ~/.grok/bin (Token Max no longer shows NOT DETECTED when Grok is open in Terminal). Projects keep a separate local folder per machine. Workrooms listLanes is live; Mac download is 0.7.48 notarized.

• Mac desktop 0.7.48 notarized — Grok path probe + Refresh detection
• Per-machine project paths (Studio vs laptop unique folders)
• Workrooms control plane: listLanes, agent runs, soft fail UI
• Privacy + Terms (Macrodeep Inc.) on grain.sh

Workrooms, fleet routing, team templates — go-live ready

Missions become Workrooms with chat, Run-on, and artifacts. One-click agent teams with role assignment. Preferred computer on web, Slack, iOS, WhatsApp, automations. Offline pin shows a waiting banner with re-route. Slack: /grain on, devices, preferred. Pricing: Starter $49 / Pro $199.

• Workrooms + artifacts; team templates assign roles / open bidding
• Preferred device on all major create paths; waiting-for-device UX
• Slack: `/grain on Studio Mac …`, `/grain devices`, `/grain preferred`
• iOS TF 36: Devices admin + Workrooms / templates
• Devices fleet checklist; hide legacy grain-desktop when upgraded
• Canonical pricing Starter $49 · Pro $199

Name your computers; cloud executor hidden

Devices list shows only real Macs/PCs. Rename to Jesper’s Workstation / MacBook / Mini. docker-executor no longer appears as a fake second machine.

• Rename + Remove on Devices cards
• docker-executor filtered out of Run-on / Devices
• Desktop 0.7.42 full matrix re-ship

Multi-device Run-on + preferred computer

Create tasks with live computer chips: preferred machine auto-selected when online, free/busy status, per-machine execution defaults in Settings → Computers. Full desktop re-ship.

• New task: Run on computer chips for every live Mac/Win/Linux executor
• Auto-select ★ preferred computer when it is live
• Per-machine Plan/Implement defaults on Settings → Execution → Computers
• Desktop 0.7.41: Mac notarized Swift DMG, Windows NSIS, Linux deb + AppImage + one-click install

Kimi Code + multi-device routing on every desktop

Kimi Code CLI (K3) joins Claude Code / Codex / Grok as a first-class coding backend. Pick which Mac runs each task. Fresh installers for Mac, Windows, and Linux.

• Kimi Code CLI backend + Kimi K3 / K2.7 models in Settings, Agents, and task routing.
• Multi-device: Run on Mac 1 / Mac 2 with Free / Executing status on web + desktop.
• Desktop 0.7.40: Mac notarized Swift DMG, Windows NSIS, Linux one-click install script.

Plan approval, Live stream, Pipeline that actually runs

The three-phase pipeline is trustworthy end-to-end: see the plan, approve it, watch a real CLI stream, and let Grok implement with Codex plan/verify. Desktop 0.7.39 ships the same day on Mac, Windows, and Linux.

• Approve-before-implement: Plan phase posts a review card on the task Details drawer — approve or reject before Implement starts.
• Live agent stream redesigned for readability: wider drawer, larger CLI-style output, phase + model labels (Codex Sol / Grok / Codex Terra).
• Pipeline routing fixes: org defaults merge on claim, model↔backend coerce, Codex via `codex exec`, Grok via `--prompt-file` + always-approve.
• Verify NEEDS_WORK soft-fails into REVIEW instead of looking like a hard ERROR with a “What Looks Correct” dead-end.
• Settings Verify (and Plan / Implement) fields round-trip correctly — no more “unsaved” on reopen.
• Desktop installers: Mac notarized DMG, Windows NSIS, Linux deb + AppImage — all 0.7.39 with the fixed local executor.

Project scan that finishes

Scan & import no longer hangs for a minute on developer machines that keep large git clones under Documents.

• Stop descending once a `.git` folder is found (Swift parity with Rust) — no walking `node_modules` / `target`.
• Prefer `Documents/GitHub` over full Documents/Desktop; skip heavy directories.
• 12s native deadline + 15s UI timeout; lightweight inspect via `.git/config` + HEAD.

Scan local repos + multi-repo tasks

Import the projects you already have on disk, then attach two or three repos to a single task when the work spans more than one checkout.

• Scan & import wizard for local Git installs and folders; manual folder path and clone URL still work.
• Multi-repo tasks (2–3) for cross-repo work.
• Mac Swift + Tauri Win/Linux shell commands for scan / detect tools / find local repo.

Live activity across every CLI

See what the agent is doing in real time — tools, thinking, and status — whether the run uses Claude Code, Codex, Grok, Gemini, or OpenCode. Clearer than a black-box spinner.

• Live activity timeline on the task: Tool / Thinking / Status / Error / Done badges with step count and CLI label.
• Same strip appears in chat while the task is running so progress stays in view.
• Executor streams Codex / Grok / Gemini / OpenCode stdout into classified progress (not Claude-only anymore).
• Tool events also show as short system chips in chat (Reading file…, Running command…, Working…).
• QUESTION: option pickers, plan approve, and interactive mode still handle direction when the agent asks.
• Mac desktop 0.7.32 notarized with the streaming executor; use app.grain.sh or reinstall Mac for the full local path.

Desktop equal on Mac, Windows & Linux

Grain Desktop ships the same product quality on every OS. macOS stays on the native Swift shell; Windows and Linux use Tauri with a full executor supervisor — install once and local agents just work.

• Windows NSIS + Linux deb / AppImage / rpm at the same version as the notarized Mac DMG — download.grain.sh and grain.sh/download.
• Executor supervisor parity with Swift Mac: health adopt on :3212, free unhealthy ports, launch on start, re-check on focus (2s debounce).
• OS-aware PATH so CLIs resolve when the app is opened from Explorer / .desktop / Dock (npm, Scoop, nvm, cargo, ~/.local, Git for Windows, …).
• Tray + Grain menu on Win/Linux: Show, Check for Updates, Restart Local Executor, Open Logs, Quit.
• Settings / onboarding download CTAs point at real multi-platform installers (not “npm run executor only”).

Simple vs Pipeline — how tasks run

Settings → How tasks run is now two clear layers: pick Simple or Pipeline for day-to-day routing, and keep Reliability as an advanced group so power options stay out of the way.

• Simple mode for one-shot local CLI runs; Pipeline for multi-phase Plan → Implement → Verify.
• Fable → Codex is a recipe inside Pipeline (not a separate product surface).
• Reliability (advanced): Parallel multi-engine, Token Max rotation, Adaptive routing — grouped so defaults stay calm.
• Mac Swift DMG and Grain Mobile (build 31) ship the same Settings + llmConfig story.

Verify fix-loop — implement until it passes

The three-phase pipeline no longer stops at the first “needs work.” Implement and Verify loop until PASS or a hard fix-round cap.

• runThreePhasePipeline: on NEEDS_WORK, re-run implement with verifier feedback (max 3 fix rounds).
• iOS/iPad New Task: Plan / Implement / Verify CLI + model cyclers; mobile API stamps org llmConfig + overrides.
• Desktop embeds the new executor so local Mac installs get the loop without a separate CLI upgrade.

Plan & implement routing on desktop

Swift Mac embeds the latest web Settings at build time — including Plan & implement routing and a quieter install CTA when the local executor is already connected.

• Per-phase CLI + model defaults for Plan, Implement, and Verify.
• Hide the big “Download for Mac” banner when executor status is Connected or you are already inside the desktop shell.

Mac auto-update check

Grain Mac checks download.grain.sh/latest.json on launch and from Grain → Check for Updates…. Newer versions open the notarized DMG URL; Later snoozes for 24 hours.

Native Swift Mac shell + Tauri Win/Linux split

Desktop shells split by platform: macOS is a native Swift host for the shared React UI; Linux and Windows stay on Tauri. Same product, better native fit on each OS.

• Swift Mac: WKWebView shell, executor sidecar, Developer ID + notarized DMG.
• Grok CLI and Gemini CLI in Settings; Grok 4.5 default where appropriate.
• Notification dropdown reliability fixes on web + desktop.

Per-task control, Fable→Codex recipe, skills & reliability

Finer control when you create a task, a practical Fable-then-Codex path for long coding runs, and a tougher on-device executor.

• Per-task run mode + Full access (never ask) in the create form.
• Plan with Fable → build with Codex as an orchestration recipe (org default or per task).
• Skills library expanded (recursive planning, spec writing, implementation, visual review).
• Executor keeps polling during long browser/2FA waits; guided Setup tab; stuck-task recovery.

Local executor that stays awake + in-app auto-update

The desktop sidecar no longer wedges at startup or freezes mid-run. Auto-update is live for Mac via download.grain.sh/latest.json.

• Poll loop starts immediately; vault scans and stats never block first claim.
• Executor logs to ~/.grain/executor.log (no more full-pipe freezes).
• Growth Agent G4 monitoring + campaign loop self-heal; server browser publishing fixed.
• Multi-agent handovers record Gemini / Grok / Hermes context; Codex can resume sessions.

Live output surface + quieter channel auth

Local runs can stream browser / editor / sheet surfaces in-app, and channel auth no longer spams Slack or Telegram when a CLI login flap recovers.

• Live browser, code/text editor, and spreadsheet viewers for on-device deliverables.
• Auth alert latch + healthy-streak dedupe so expired CLI login does not flood every poll cycle.
• iPad auth full-width login/signup with real mobile API (not mock-only).