What shipped, as it shipped

Shared mailboxes: support@ in Mail for the people who answer it, and in workflows for the projects given it

A mailbox several people answer. Somebody with Manage connectors adds one in Settings ▸ Connectors ▸ Shared mailboxes: signing in as the mailbox with Google, as somebody with Full Access to a Microsoft 365 shared mailbox, or with a mail server's password. The next step asks who reads it, with you already on the list, and which projects may use it, with none chosen until you pick. Its page holds who signed it in, the name it sends as, its members (people, and roles), its projects, its signature, its rules and Disconnect. Managing connectors doesn't make anybody a reader.

In Mail, for its members. It sits under your own mailboxes, headed with its organization's name. Read and starred marks and drafts are the mailbox's, so a thread a colleague is answering says Grace's draft, and a reply goes from the mailbox with its signature. Your unified folders stay your own. Create task from one of its threads offers only the projects it is given. Settings ▸ Mail lists it under Shared with you, where its menu says whether it reaches your phone: nobody, until you choose. Its rules file tasks, start runs, archive, mark read and star, as the organization, and never send.

In workflows. An on: mail trigger can hear a shared mailbox the project is given, acting as the organization. A mail step with from: support@acme.com drafts a message the mailbox sends: its review shows From locked to the mailbox, and only its members who hold Send mail from runs may approve. Anybody else can change the draft and save it for them.

On the web, the desktop app, the iPhone, the iPad, the Mac and Android.

Chat search as a palette, Threads and Later as cards, and pins in the header

Search opens over the conversation. On the web, the desktop app, the Mac and the iPad, Chat's search is a palette: type, or pick a filter it offers, and ↑ ↓ and Return open a message.

Threads, Later and Activity read like the conversation. A followed thread is a card with the message it answers, its newest replies and how many are new. A saved message stays in Later until you take it off with Remove, and Activity is grouped by day, with what each one was.

Pinned messages show under the header. A press goes to the one shown and turns to the next.

New message shows the people you pick as chips, files a long list under Recent, People and Agents with each status, and says Open when you already have that conversation.

Reactions are filled and animate as they come and go, and Add reaction opens the picker. A voice clip's waveform is grey with the played part in colour, and its transcript opens from a pill at the end of its row. Polls have fewer lines, the typing line is smaller and sits under the message box, and a note only you can see says so in its header.

A conversation's details open beside it, and Chat on the Mac is tighter

Details beside the conversation. The info button opens a conversation's About, Members, Pins, Files and Settings in the pane where a thread opens, on the web, the desktop app, the Mac and the iPad, instead of in a dialog. A thread and the details take each other's place, and the same button closes them. On a phone they stay a page of their own.

More reactions is a popover over the message on the Mac and the iPad, and the Mac's message menu has an Add reaction submenu.

Smaller faces beside messages, on every client. Hovering a message that runs on from the one before shows its time in one line, and the row no longer moves.

Every chat sheet now ends the way the app's other sheets do. That covers New message, Add people, Forward, New channel, Status and New poll. New channel opens inside Browse channels, and the Files tab shows each file's kind and size.

A new server reaches no project until you choose, and a draft's review carries the actions held beside it

A new server starts with no project. Registering one of your organization's MCP servers asks Which projects may use it?, with nothing chosen. Without Manage connectors you can still register it, and it waits for somebody who holds it. That holds however the server is made: in Settings, by the assistant, through MCP or the public API. Servers you already have keep their projects.

A draft and its actions in one review. When a phase holds a message, an event, a document or a plan and also actions on a connected service, the draft's review lists the actions under Held actions, each one a form you can change or discard. One button does both: Approve, send and apply 2 actions. Without Act on connected services from runs it is Save changes. Before, the actions could only be read on the phase.

Request changes doesn't repeat what already happened. A tool call that went through at once can't be undone by running the phase again, so the next attempt is told what the earlier ones did and what each service answered, and builds on it instead of doing it twice.

A tracker's page on the web. It is headed with the account and what uses it: Acme workspace, Linear · Tracker in Peractor and Mobile app. Its Remove Linear, which took the account away from every project while saying it was this one, is Disconnect Linear and says so. To take one project off, untick it under Projects. The tasks the account synced stay, unlinked. Slack's and Discord's notifier pages on the web now have Projects too, as the apps' already did.

Fixed on Android: a server added to the organization's library was saved into the open project's settings instead, and a change to Projects the host refused looked saved.

The question and the review are on the web, the desktop app, the Mac, the iPad, the iPhone and Android.

Your connections reach only the projects you choose, and a run's outside actions wait for you

Projects on every connection. A tracker's connection and each of your organization's MCP servers now say which projects may use them: All projects, or Only these with a tick for each. A project that isn't on the list doesn't see the connection, and its runs don't get the server. Each project says what it takes from the connection, so taking one off tells you what stops first. On the web, registering a server that can reach outside your organization asks which projects may use it, with nothing chosen. Existing connections keep every project. Changing it takes Manage connectors.

No server token in a run. A run's agent reaches a server through Peractor. Each call is checked against the projects and the server's tools, made with the token on Peractor's side, renewed so a long step never loses the server, and kept in the audit log. A server that runs as a command inside the sandbox works as before, and its page says so.

Live, Waits for a person, or Off. Each tool on a server's page has a setting. A read-only tool starts Live; every other tool starts waiting.

Actions that wait for you. When an agent calls a tool that waits, the call doesn't happen: the phase ends on a review, and the run says 2 actions wait for you. Review them, change what each one asks for or discard it, then Approve and apply. They happen in order, as your organization, and the next phase is told what each one answered. Approving needs the new Act on connected services from runs permission. See Gates & reviews.

Projects, Tools and the review are on the web, the desktop app, the Mac, the iPad, the iPhone and Android.

Office files do what most people need: formulas, headers and footers, suggestions, footnotes and charts

Spreadsheets. About 60 everyday functions now calculate: logic such as IFS and SWITCH, maths, the SUMIF and COUNTIF families, lookups such as VLOOKUP, XLOOKUP and INDEX with MATCH, text, dates and the IS checks. Names a workbook defines work in its formulas. Numbers show in their file's formats, with Format ▸ Number to change them, and conditional formatting is drawn, with highlight cells if and colour scales to add. Cutting, pasting and dragging cells rewrite the formulas that point at them, and pasting from a web page or another app keeps basic formatting. Insert chart asks for the range as well as the title and type, and Edit chart changes them later.

Documents. Headers and footers with page numbers or Page 1 of N, and a different first page; a table of contents from your headings, with links and Update; Suggesting, which records what you type as tracked changes under your name, with accept and reject one at a time or all at once; a table's cell fill, borders and a header row that repeats on each page; and footnotes that renumber themselves.

Presentations. Copy, cut and paste objects between slides and decks with their pictures and charts, and paste pictures and text from other apps. Charts already in a deck are drawn from the figures saved with them, and a chart, SmartArt or any object the editor doesn't draw moves, resizes, reorders, copies and deletes as a whole, with what it holds kept as it was.

On the web, the desktop app, the Mac, the iPad, the iPhone and Android. On the Mac, ⌘-scroll now zooms a large diagram smoothly.

Chat: your organization's own messenger, with your agent teammates in it

Chat is new on the web, the desktop app, the Mac, the iPad, the iPhone and Android: public and private channels, direct messages with up to nine people, threads, mentions, reactions with a full emoji picker, files, voice clips with transcripts, polls, link previews, search, unread state, presence, your status and push notifications. Every organization starts with #general.

The message box keeps to one row: the + at its start attaches photos and files or starts a poll, and the emoji picker and the microphone for a voice message sit at its end. A channel of hundreds of thousands of messages stays quick to open, scroll and search, a thread opens at its newest replies, and a count past 999 reads 999+.

Your agent teammates are members: add a persona to a channel or message it, mention it, and its answer is written into the thread as it works. Links to tasks, runs, files, wiki pages and workflows open out into live cards, read for each person, and any message can become a task. Runs can post their milestones into a channel through the new Peractor chat notifier, an on: message trigger starts a workflow from a channel's messages, and a conversation can start a call through your organization's Zoom, Meet or Teams. See Chat.

An app connected over MCP reaches your conversations only with the new Chat through apps permission ticked when you connect it. One you connected before reads as Custom and has no Chat until you connect it again.

Agents ask with pictures, sliders, dates and files

When an agent stops to ask you something, it's no longer limited to four multiple-choice questions. It asks as many as it needs, and each one can be a choice, a scale, a date, your own words or files. Choices can be cards with icons or pictures, or tiles that are pictures — mockups and screenshots to compare side by side — and an option can show the code it would write when you pick it. A set can start with the background you need: text, code or a screenshot.

A short set is answered right in the run, as before. A long one shows a line per question and Answer in a tab, which opens the whole set with room to read it and a Send button that answers the run. On iPhone and Android every kind is drawn in the answer sheet, one question per page. Slack and Discord threads link straight to it.

Offline says so in a strip at the top of the phone

On iPhone and Android, being offline is now a thin gold strip across the top of the screen, the status bar included, that says You're offline on every page. It replaces the amber icon each screen used to put in its header. When Peractor itself isn't answering, the strip says Can't reach Peractor instead, and over a file you're editing it adds that your edits stay on this device. When the connection comes back it turns green for a moment, says Back online, and goes. Tap it to read what ends it. The Mac and the iPad keep their one mark beside back and forward.

See a run's files at its gate, and larger folders on your own machines

When a phase changes a wiki or Assets folder kept outside the repository, its gate lists the files approving saves. Each one now opens: the run's version shown as itself — a page rendered, a picture drawn — and a Changes tab with what changed in its text, Office files as their paragraphs, cells and slides. Every other file the phase changed is beside it, and you can approve or request changes from there. Over MCP, get_run_diff with folders reads the same change, and the assistant sees it on runs waiting for you.

A machine you paired now fetches a folder's larger files itself: past 10 MB a file or 64 MB a phase, up to 2 GB, through a link that reads only that phase's files and ends with it. It never holds the storage's keys. See Storage.

See each other's carets in Markdown and code, in every app

In a live Markdown or code file on the Mac, iPhone, iPad and Android, the others in it now show where they are, as they already did on the web: a caret in their colour with their name over it, and the text they have selected tinted. Their carets move with your typing, and jump to where they are whenever they move.

On iPhone and Android, somebody who can read a Markdown or code file but not edit it now watches it live too, as they already could on the Mac, the iPad and the web: the text changes as others type, with their carets in it and their faces in the header. See Code.

Edit files offline

A lost connection no longer stops you working on a file. A document, workbook, deck or diagram you have opened in Code stays on your device, and you can keep editing it with no connection: Peractor's Office editor now runs on the device itself, so every command that changes the file works as it does online.

Your edits wait, then merge. Each edit is written to the device as you make it and shows in Changes as Waiting to send. When the connection returns it goes up as your commit. If someone changed the file meanwhile, the two merge — a document paragraph by paragraph, a workbook cell by cell, a diagram shape by shape, a deck by replaying your slide changes — and where they can't, Code asks which version to keep. Nothing is overwritten quietly. Office files you save into Changes now merge the same way, online or not.

Choose what to keep. Mark a file or a folder Available offline from its menu, and Settings → Offline files shows the space used, what is marked, and what is still waiting to send. New file works offline too, blank or from a template the device has kept, and an older .doc or .xls you have opened before opens read-only.

It says so. An open file shows a connection mark while it can't reach Peractor, and commands that need the server — PDF export, Present, History, Versions, Share — leave the menus until you're back. In a browser, the dashboard now opens without a connection too.

On the web, the desktop app, the Mac, iPhone, iPad and Android. See Working offline.

Your own run images

A phase can start from your organization's own image now, instead of Peractor's: one pulled from your registry, or one Peractor builds from a Dockerfile in your repository. A pinned Node, CUDA, Elixir, a system library or your company's own CLI is there from the first step, rather than downloaded on every phase.

Name it beside Runs on. An Image field sits under Runs on in the phase editor, the workflow's defaults and the run defaults of a project and the organization; the nearest one wins. In YAML it is image:, a reference or build: { dockerfile, context, secrets }.

Your registry, your sign-in. Settings → Registries keeps a sign-in per registry — a username and token for GitHub's, Docker Hub, Google's Artifact Registry, GitLab's or any other, or an access key for Amazon ECR, which Peractor turns into a fresh token for each pull. Each is tested before it is kept, and none ever reaches a run.

Built from your repository. A Dockerfile is built from the run's base branch in a sandbox of its own, under the run's limits and behind its egress allowlist, with restricted files left out and only the secrets the workflow lists. Its log is the phase's first entry, and the same files are built once. A host that serves more than one organization builds only under gVisor, as Peractor Cloud does.

The same image, start to finish. Your image needs only a shell: Peractor mounts its runner, git, Node and the agents beside it, read-only. A run pins each image's digest the first time it is used, so every later phase, retry and resume runs the same image. The run view shows it beside each phase, and the audit log records it. What Peractor pulls and builds is kept for your organization alone, up to your plan's allowance on Billing & usage.

On the web, the desktop app, the Mac, iPhone, iPad and Android.

Booking pages

Everyone has a booking page now, in place of Calendly: a public link where a customer, a candidate or anyone without a Peractor account picks a time you're free, and the meeting lands on your calendar.

Your page, your hours. In Settings → Scheduling, set your working hours and dates off, and offer kinds of meeting — an intro call, a demo, a review — each with its own link, length, place or video call, questions to ask, buffers, notice and how far ahead. Free time is your hours minus what is already on your Peractor calendar, in every organization you're in.

Teams. A team page over a role gives each booking to the member who has had fewest lately, or books everyone at a time they're all free.

When someone books. The event is on your calendar with their answers, and with a Zoom, Meet or Teams call when the kind asks for one. They get a confirmation with an invitation for their own calendar and a link to reschedule or cancel, and a reminder before; you hear it in your inbox and by mail. Moving or deleting the event in your calendar moves or cancels the booking, and tells them.

Workflows hear it. A new on: booking trigger starts a run when a time is booked, moved or cancelled, with the visitor's answers handed to the run as material. The assistant and MCP read and change your pages too; cancelling a booking always waits for you.

Calls on Zoom, Meet and Teams

An organization or project event can carry a video call now, made in your organization's own Zoom, Google Meet or Microsoft Teams — and after the meeting, its transcript lands in the project's Assets, where people, agents and workflows can read it.

Install once, for everyone. An admin installs a provider in Settings → Connectors, consenting for the organization's whole account. Each install says whether calls record and transcribe automatically — transcribing on, recording off unless you change it — and whether transcripts and recordings are kept, each in a folder of its own. There are no personal installs, and Peractor makes no call on a personal event.

Add a call on an event you can edit. The event's owner hosts it, matched by their address in the provider's account; Peractor says why when it can't. Moving the event moves the call, deleting it cancels the call, and a meeting link pasted into an event joins it to the same watch when it's your account's. Join shows on the event and on its reminder from fifteen minutes before.

After the meeting. Peractor checks back until the provider has the transcript, and keeps it as a Markdown file, speaker by speaker, in the event's project; a recording is kept only when the install says so. Who can read them follows the folder they're in.

Workflows hear it. A new on: meeting trigger starts a run when a meeting ends, its transcript arrives or its recording does — with its title, attendees and transcript handed to the run — and the calendar step can propose an event with a call. The Meeting notes workflow in the Office work pack turns a transcript into notes, proposes the action items and mails the notes to the people who came, each waiting for your approval. The assistant and MCP read a meeting and its transcript, and can add a call.

On the web, the desktop app, the Mac, iPhone, iPad and Android.

Shared projects

The organization's libraries are projects now. Share a project with the organization and every other project can pick its workflows, instructions, personas, skills, task templates and memory — the way projects picked from the organization's library before.

Your default shared project. Every organization has one, named after it, holding everything the organization's library held — under the same names, so nothing a project picked changed. It is listed first wherever a project picks, every new project receives its memory, and a pack lands there unless you choose another project. Organization settings choose which shared project is the default.

Share a project. A switch beside Private in the project's settings, for whoever holds the new Share projects permission. A shared project can't be private, and it can't stop being shared or be deleted while another project picks from it — the refusal names them.

Picking, grouped. Shared library screens group what is offered by the project it comes from. A picked workflow runs in your project, against your repository and board, and finds its instructions in the project it came from. Memory this project receives on a project's memory chooses whose memory its agents are told.

Personas live in projects, in project settings, running their own project's workflows. Credentials stay with the organization: connectors, MCP servers, agents, machines and storages. Old links to the organization's workflows, instructions and personas open them in the default shared project. All of this is on the web, the desktop app, the Mac, iPhone, iPad and Android, and the assistant and MCP can share a project too.

Keep a folder where it belongs

A wiki folder, an Assets folder or a project's memory no longer has to live in the project's repository. Keep it in Peractor's database, its object storage or its git — or in a bucket or repository your organization already has. The truth is whichever storage the folder is on, so a file someone changes straight in your bucket is the one Peractor shows next.

Your own storage. Settings → Storage lists where the organization's files can be kept. Add a bucket takes any S3-compatible bucket, its secret key sealed and never shown again; Add a repository uses your git access. Test checks it, and says whether a bucket keeps earlier versions.

Move a folder. In a project's Settings → General, every folder shows where it is kept. A move copies every file, checks each one arrived whole, then switches — and the old copy stays where it was.

Storage on your plan counts what Peractor keeps, split by storage on Billing; your own buckets and repositories count nothing. Shared Assets links now survive a restart of the host.

Runs work in it. A run's workspace holds the wiki folders kept elsewhere, and Assets folders it includes, at their paths. What it changes there is never committed: the phase's gate lists the files, and approving saves them. A file somebody changed meanwhile stops the approval and says which.

History and large files. The wiki's and Assets' History show each save to a folder kept elsewhere, with who saved it, and a storage can be edited in place. An upload of 16 MB or more resumes after a dropped connection, and a large video in a bucket plays straight from it.

A folder kept outside the repository has no branches. All of this is on the web, the desktop app, the Mac, iPhone, iPad and Android.

Front matter, read as properties

A Markdown file that opens with front matter — a Jira-style key, a status, a due date, a list of labels — now shows those values as properties over the text in Preview, typed as words, numbers, dates and checkboxes. Edit source is still the file as written, so adding or removing the front matter is just an edit.

Markdown by any name. .mdown, .mkd, .mkdn, .mdwn and .mdx files open as Markdown, with a preview and its modes, and reStructuredText files read as source with their own icon.

Modes on a phone. On iPhone and Android every switch between a file's preview and its source is one bar in words under the header, never a button in it.

A divider in Side by side. Drag the line between the source and the preview to give either more room; a double-click puts it back to half, and the split is remembered.

On the web, the desktop app, the Mac, iPhone, iPad and Android.

A record's page, as text

A record the assistant opens in the editor — a Jira issue, a Notion page — now opens in three modes, named as an Office file's are: Preview reads it, Edit content edits its properties over its text, and Edit source edits the page itself, front matter and all. A Save from Edit source is held to the service's fields like any other, and a page whose front matter does not read says why and keeps you in it. On the desk, Side by side still sets Edit content beside its preview.

On the web, the desktop app, the Mac, iPhone, iPad and Android.

A workflow step that waits

A new step, wait, parks a run until something happens: a review on its pull request, a reply in its mail thread, its task moving, a metric crossing its line, or simply a time passing. It listens the way a trigger does — the same events, the same fields, the same filter — and gives up after its timeout, carrying on or failing the step as you choose.

No machine held. A waiting run holds no machine, does not count against your concurrency or its time limit, and shows as Waiting rather than as something that needs you. Continue now on the run carries it on at once.

What it heard. The steps after it read the event that ended the wait, as data for the workflow to act on — never as instructions. MCP and the assistant can continue a waiting run too.

Versions, and comments in workbooks and decks

Versions. A file's history is its versions, newest first. Name the ones that matter — "Sent to legal" — and File history shows the name in place of the commit message, with Named only to list just those. Compare with current shows what changed in the document, workbook or deck since then, and Restore puts the file back as a new version, live for everyone who has it open.

Comments in workbooks and decks. Comment on a cell, a slide or a shape, reply, resolve and reopen, with everybody in the file seeing it as it happens. Comments are written the way Excel and PowerPoint write them, so they are there when the file opens in Office.

On the web, the desktop app, the Mac, iPhone, iPad and Android; the assistant and MCP name and restore versions too.

Question lists, and a service's own screens

Question lists. The assistant can open a form, survey or questionnaire from a connected service as a workbook: one question a row, with each answer cell checked by its question's kind — a choice from its options, yes or no, a number, a scale, a date. Save sends the answers back and says which questions changed, moved or went.

A service's own screens. When a connected service ships its own view of what a tool answered, it shows in the conversation's card, in a sealed frame that can reach only what the service declared. Anything it asks to change waits for your Apply outside the frame, even in Auto; a message it suggests lands in your composer for you to send. An admin can switch a server's views off.

Triggers: filters, caps, batches, Acts as me, and reviews

Five settings now work the same on every trigger, whatever it listens to.

One filter. A condition over the event's fields, written the way a phase's when: is — mail.from == "*@acme.com" && mail.subject != "*unsubscribe*", pr.base == "main", metric.number > 5. Test and the delivery log print the values it read.

At most. perHour and perDay cap the runs one trigger starts, below your organization's quota.

One run for many events. collect: 1h gathers an hour of events into one run, and debounce: 10m waits for things to go quiet. The run reads every event it gathered.

Acts as me. A trigger can act as the person who turned it on: its runs start as them, see what they see, and bring their gates and questions to them. Nobody can make a trigger act as somebody else.

Reviews and comments. Approvals, change requests and comments on the pull requests people wrote, on GitHub and GitLab, can start a run. And a webhook can file what it receives as a task, as mail already could.

On the web, the desktop app, the Mac, iPhone, iPad and Android — and through MCP, which can now save and remove triggers, the public API's new /api/v1/triggers, and the assistant.

A shell in a run's workspace

A new step, terminal, stops a run for a person to work in its workspace from a shell — sign a build, poke at a database, re-run the test the agent couldn't explain — and carries on when they press Done. What they change goes out with the phase's commit.

On every surface. The shell opens under the transcript on the web and in the desktop app, beside the transcript on a Mac or an iPad, and full screen on a phone, with Esc, Tab, Ctrl and the arrows in a row above the keyboard.

Resume, with or without a terminal. When a phase fails and keeps its work, the failed step's menu now offers Resume from this step on every client — the phase runs again from there over what the earlier steps produced — and Resume with a terminal, which opens a shell in that work first so you can look into what broke before the step runs again. The failure banner now says the work is saved, where it used to say it was discarded.

Who may. The shell holds the run's secrets, so opening one needs the new Open terminals permission, which nobody has until a role grants it, and a step can narrow it to the roles and people it names. Each session is in the transcript and the audit log; what was typed is not stored.

No machine held. While nobody has a shell open the workspace is saved and the machine given back; opening it again brings it back.

Edit a file together, live

Open a Word document, a workbook, a deck, a diagram or a CSV that somebody else has open, and you're both in it. Type at the same time: each edit is merged into everybody's, and nothing anyone typed is lost. Markdown and code files are live too.

See who's there. Their faces are on the file's status line, each in the colour their cursor, cell or selection wears in the file — on a slide or a diagram, the shapes they hold are outlined in it. Press a face to go to their sheet, slide or page. Somebody who can only read the file watches the edits arrive.

Nothing to save before you leave. The file is committed when somebody presses Save, after a couple of quiet minutes, at least every quarter of an hour, and when the last person leaves — authored by whoever wrote last, with everybody else who wrote as a co-author. Close the tab, lose the connection, or have the host restart: what you typed is kept.

Agents too. When the assistant, an MCP client or a run writes to a file you have open, its edit arrives in the file with its own face, rather than as a conflict when you save.

Time limits on steps, phases, runs and agent turns

A test that hangs, a server started in the foreground or an agent going round in circles no longer holds its machine until somebody notices. Every piece of a run's work now has a limit, and one holds with nothing configured: an hour for a command or check, two for an agent's turn, four for a phase and twelve for a run.

Set them where the work is. A step's timeout:, a phase's, or the workflow's defaults.timeouts — in every editor, written 20m, 1h30m or 2h. Your organization sets the longest each may be, and a project can hold its own lower.

Waiting isn't work. Time at a gate, on a question, at a preview, in a conversation with a step or in the queue doesn't count, and lanes working side by side count once.

At the limit, it stops and says so. The step's process and everything it started are stopped. A check is red and its agent may fix it; a command fails its phase; an agent's turn ends with its work kept, so Resume from this step carries on. The card says "timed out after 20m", and a machine that doesn't stop is stopped for it.

Servers in the background. A server started with & no longer holds its step open, and is stopped when the phase ends.

Python, Go, Java and Rust on the machine pool

A check step on a repository that isn't JavaScript can now run its own tests on Peractor's machine pool, without downloading a toolchain first. The image carries Python with pip and uv, Go, Java 21 with Maven and Gradle, Rust through rustup with clippy and rustfmt, and gcc and make, beside Node.js.

No root needed. pip install, go install and cargo install work as the run's own user, and a rust-toolchain.toml, a newer Go in go.mod or a Python uv fetches gets its own version.

A missing program says what is there. A step that exits 127 lists what the image has, and the Machines & isolation guide lists every program with its version. A paired machine still runs with whatever is installed on it.

Issues and rows from a service, as typed records

A tracker's issues, a database's rows or a CRM's contacts now open as records, each field typed from the service's own tools.

Many records are a sheet. A status column is a dropdown of the service's statuses, a date column a calendar, a number column takes numbers. A value a column can't hold is refused as you type it, in the formula bar's picker and in the cell. The types are the workbook's own data validation, so Excel and Numbers keep them.

One record is a form. Its fields as the controls they ask for, and its description in the Markdown editor under them, on the web, the desk and the phones.

Save is record by record. The plan names what changed in each record, the rows that are new and the ones you removed, and stages the service's own update, create and delete for each. A value the service won't take stops the save first, with the record and field named.

Edit what a connected service holds, in Peractor's editor

Ask the assistant to open a sheet, a document or a page from any service your organization connected, and it opens as a draft in Peractor's own editor — the spreadsheet, the document and slide editors, or Markdown — on the device you asked from.

One draft for you and the assistant. It edits the draft through the plan you approve; you edit it in the editor. Nothing about the service is built into Peractor: the assistant reads it with the service's own tools, so one connected next week works the same.

Save writes it back after you look. Save opens the plan beside the draft: what changed against what was read, and the service's calls that write it. Peractor reads the item again first and writes nothing if it changed there since; a save that stops partway says what landed. Revisions, Restore and Discard are in the draft's menu, and the original is never touched until you apply.

Mail, the calendar and documents inside workflows

Business work now goes through the same machinery as code: triggers start it, gates hold it, and a person decides what leaves.

Three new steps. A mail step drafts a message; a calendar step proposes an event or a block of your own time; a document step writes or updates a Word document, a workbook, a deck, Markdown or CSV. A message and an event always wait at their phase's gate: Review message lets you change who it goes to and what it says, and approving sends it from your mailbox — in the conversation when it is in your mail. Approving an event books it as you and invites anybody outside the organization by mail. A document is committed with the rest of the work, and its gate shows it rendered, with what changed in its text.

Two new triggers. Mail starts work when a message matching your conditions arrives in one of your mailboxes — a taskless run carrying the conversation, or a task filed into triage — and one conversation is one piece of work, whatever its replies. Calendar fires before, at the start of, at the end of or after an event: "thirty minutes before a customer meeting, prepare a brief".

Sending mail from runs and inviting people outside the organization are permissions of their own, every send is in the audit log, and neither the assistant's Auto mode nor a connected MCP client can approve one. The new Office work pack has four workflows to start from.

MCP servers you sign in to

An MCP server that asks you to sign in rather than paste a token — Google Workspace's and Microsoft 365's official servers among them — can now be registered. Set The server expects to A sign-in (OAuth) and press Connect: the service's own sign-in page opens, and Peractor keeps the sign-in for your organization, encrypted, and renews it. Every run step that carries the server starts with a fresh token, the assistant uses it the same way, and no token ever reaches a file, a command line or a transcript.

Peractor registers itself with services that allow it. For those that don't, register Peractor yourself and enter the Client ID (and client secret) — the Sign-in block shows the redirect URI to give. A sign-in is tied to the server's address, and signing in or out is in the audit log. Ask the assistant and it hands you the same Connect on a card. On the web, the desktop app, iPhone, iPad, Mac and Android.

The assistant uses your connected services

The MCP servers your organization registers are now the assistant's tools as well as your runs'. It asks each one what it offers when you send a message — its tools, what they take and its own notes — so any server works the day it is registered, with nothing for Peractor to learn first. Look something up in Linear, add a row to a sheet, or import a sheet into a project's Assets, in one message, and combine a service's tools with Peractor's own.

A tool the service marks read-only runs while the assistant works, and each call shows in the conversation. Anything else becomes a step of the plan, showing the tool, the service and what it sends: it runs when the plan is applied, after the plan's Peractor changes, and the assistant then tells you what was made there, with its link. In Auto, a step waits for your yes unless the service promises it leaves what is there alone.

A conversation reaches the servers a run in its project would get, and an organization's whole list for the people who manage it. Peractor makes every call itself, so the token never reaches the assistant, and every call lands in the audit log. Servers are reached over HTTPS, never on a private network; one that runs as a program beside the agent stays a run's.

Tracker issues are Peractor tasks, kept in step both ways

A connected tracker's issues are now tasks like any other. They stand on your project's one board, in your own statuses, each wearing its tracker's mark and key — every tracker's state lands in the status of its category, and each tracker's settings page lets you pick where each state lands and what a move here writes back as. Workflows name your statuses, so one pipeline drives every task.

Edit a synced task here and the change goes back: title, description, status, priority, assignees, labels and due date to Linear, Jira, GitHub Issues and GitLab; status and comments to GitHub Projects, pull requests, Notion, Slack and Discord. When both sides changed a field, the later edit wins and the task shows both, one press from the other. A write the tracker refuses is shown and retried. Comments cross both ways, and people are matched by email or sign-in.

New tasks go out only when asked: Also create in Linear on the form, Create in Linear on a task, or a project-wide New tasks also go to. Unlink stops syncing and keeps the task; deleting one never touches the issue; disconnecting a list keeps every task it synced. Peractor's tasks can no longer be switched off, and the separate Import is gone — connecting and unlinking does the same move.

Triggers hear the board, milestones, gates, metrics, memory and your organization

Triggers can now start work on Peractor's own events, not just a schedule, a push or a webhook. A task trigger fires when a task is filed, gets a label, is assigned, gets a comment, is unblocked, comes due or goes overdue — so a needs-spec label can run a spec writer and an overdue task can get a nudge drafted. A milestone trigger fires as one comes due or is completed. A run trigger now hears a gate opening or being decided, a question, a plan filing its tasks, a run waiting longer than you allow, or one costing more than a limit — so a stuck review can escalate itself.

A metric trigger watches a value in the data store and fires once each time it crosses a line, changes, or stops being written. A memory trigger fires when a proposal arrives or has waited too long. And an organization trigger reads the audit log for members joining, changing roles or leaving, and for projects, keys, secrets, connectors and machines — onboarding and offboarding workflows, set up by someone who can read that log. Every one goes through the same guards, test and delivery history as the rest, a change a triggered run made never starts the same trigger again, and the forms are on the web, the desktop app, iPhone, iPad, the Mac and Android.

Projects without a repository keep their files in Peractor

A project no longer needs a git repository to keep a wiki, an Assets library or documents. Leave the repository empty when you create one — or open any project that never bound one — and Peractor keeps its files: the wiki and Assets turn on and simply Save, documents made in the Office editors have somewhere to live, its memory is kept with them, and what its runs produce lands there once merged. Nobody on a marketing, sales or ops team sees a branch or a commit; Code still shows every file and its history.

When a team grows into engineering, Move to GitHub or GitLab… in the project's settings pushes the files, their history and their large files into an empty repository and works there from then on. Unbinding a repository now keeps a copy of its files instead of leaving the project empty. An API key can clone a project's files from Code's Clone…. Storage is part of each plan — 1 GB on Free, 10 GB on Pro, 100 GB on Team — and Settings → Billing shows what is used.

A new diagram editor for draw.io files

Diagrams open on an endless canvas on the web, the Mac, iPhone, iPad and Android. Pick a tool from the bar or press its key and drag to draw: rectangles, diamonds, ellipses, arrows, lines, freehand pen, text and pictures. Start typing to label a shape. Drag from a shape's edge to attach an arrow that follows it, bend an arrow by dragging its middle, and line shapes up with the guides that appear as you move them. A style panel changes colours, fill, stroke, sloppiness, corners, arrowheads, text and opacity; Shapes adds draw.io's general, arrow, flowchart and container shapes; right-click or touch and hold for copy, paste, group, order and lock; pages are tabs along the bottom. Undo goes back step by step.

Files stay .drawio.svg, so they still open in draw.io and preview anywhere a picture does. Save writes only what you changed and leaves everything else exactly as it was. Groups, rotation, routed connectors, HTML labels, sketch style, pictures and several pages now edit too; anything the editor cannot change is drawn as it is and kept safe. New file → Diagram starts one.

Personas: agent teammates you hand tasks to

A persona is an agent teammate — a QA Specialist, a Technical Writer, a Security Reviewer — that you hand work to the way you would a colleague. Make one in Settings → Personas, beside Members: a name and a picture, its own guidance, the instructions it carries, the shared workflows it runs, its agent, a role that says what it may do, a monthly token budget and working hours. A project picks the personas that work in it, and they appear in its assignee pickers and @mentions, marked as agents.

Assign a task to a persona and it runs one of its workflows in its turn — inside its hours, under its budget, one task at a time unless you let it take more. The run reads "Assigned by Sam · done by QA Specialist", and it can never do more than the persona's role, or than the person who assigned it. @mention one in a comment and it answers in a conversation you can carry on. A plan step can hand the tasks it files to personas, so a PM persona plans, an Engineer builds and a Security persona reviews, each when its turn comes.

What was called a persona before is an Instruction now: the reusable prompt a step carries. A persona can carry instructions too.

Instructions: the reusable prompts a step carries

The reusable prompts you attach to a workflow step are now called Instructions everywhere: the library in Settings, the step editor's picker, the organization's shared library, packs, the setup wizard's starter set, the assistant and MCP. A step lists them beside its own prompt, instructions: [frontend, house-review], and they layer in that order.

An instruction has its own icon now, a page with a prompt mark, and the guides describe it as what it is: standing guidance written once — how this codebase does things, the bar for done, what to leave alone — rather than a role for the agent to play.

Open any file in the app you use for it

Open in… now works for every file, not only code. In Code, the wiki, Assets and a run's changes, a Word document opens in Word, Pages or LibreOffice, a spreadsheet in Excel or Numbers, a presentation in PowerPoint or Keynote, a PDF in Preview or Acrobat, and pictures, diagrams and videos in their own apps. Each kind starts with your computer's default app; Open With… picks another, or Other… any app you have, and Peractor remembers it for that kind of file.

The Mac app and the desktop app list what is installed. On iPhone, iPad and Android, Open in… hands a copy of the file to an app on the device.

Ask Peractor about anything you select

Select text almost anywhere in Peractor and choose Ask Peractor. That covers a document, a wiki page, a task, a run's output, a mail, a web page or PDF you opened, and the assistant's own replies. The passage goes into the assistant with the page it came from, and the cursor is already in the message box, so you can type your question straight away. The passage rides with that one message. The message box you type into never offers it.

On iPhone and iPad, touch and hold a reply, a description or a run's text, or select text in a document, a mail, a web page or a PDF. On the Mac, mail, web pages and PDFs now offer it in their right-click menu too. On Android it now appears in every sheet and dialog, in mail and web pages, and in more of what you read: run errors, descriptions, commits and read-only diffs, and holding an assistant's answer selects its words rather than copying all of it: Copy reply in that menu copies the whole answer. In the file viewer and the preview browser, the menu no longer runs off the right edge of the screen when you select text near it. On the web and in the desktop app, the chip above a selection now appears over the assistant's replies, in the code, Markdown, Word, slide and spreadsheet editors, and in mail. The desktop app's right-click menu offers it too.

Ask about selected text in Mac readers

Select a passage in a rendered report, wiki page, description or reply on the Mac and its context menu now offers Ask Peractor. It opens the assistant with the selected passage and the page you are reading attached, as the code and document editors already do.

See when the assistant needs you

The assistant's sparkles now turn blue while it works, amber when proposed changes await approval, and green when a completed update is ready to check. Its status keeps updating after you close a conversation. Open that conversation to clear green; approve or discard its plan to clear amber. The phone grip and the assistant buttons on iPad, Mac, web and the desktop app use the same colors. On phones, the grip starts near the bottom edge; any position you choose by dragging stays saved.

Link an event to its task

An event in your calendar can now name the task it is about: Link a task in its panel finds one among the open tasks of the organization the event is kept in, by title or key, and on a project's calendar among that project's. A task's deadline says its status in its board's own words in every organization you belong to, not only the project you are working in. On Android, hold an event and drag it to another time or day to move it, or a deadline to another day to change its due date, as you already could on the web and the Apple apps.

Your calendar on Android

On Android, Calendar is the button in the drawer's header beside the assistant and the inbox, and it opens the same calendar the web and the Apple apps show: every organization you belong to, each organization and project a calendar you show or hide. It opens on the day under a strip of its week; press the month's name to see the week, the month or the agenda, and the round button to add an event. An event opens in a sheet with its calendar, people and alert, and a task's deadline opens with its due date, the time you reserved for it and the way to the task. The project's own Calendar tab and the organization's Calendar row are gone.

Documents, workbooks and slides, redone for phones

On the iPhone and on Android phones, Word documents, workbooks and presentations open in a new editor. One bar under the page holds Undo and Redo, Format, Insert, Find and the document's own menus; the header keeps what belongs to the file. While you type, the same bar holds Bold, Italic, Underline, lists, indents and Link above the keyboard.

Format opens a panel at half height, so the page shows every change: Text and Paragraph for a document, Text and Cell for a workbook, and Text, Paragraph, Shape and Slide for a presentation. Emphasis, alignment, lists and indents are one row each; fonts are listed in their own face and colours open the document palette.

A workbook's formula bar now sits above the grid, and its sheets sit along the bottom: press the sheet in front for its menu, or hold any other. A presentation's slides are numbered thumbnails under the slide, ending with New slide — hold it to pick a layout.

Your mail in Peractor

On the web dashboard, Mail is the envelope in the top bar beside the calendar and the inbox. Connect Google or Microsoft by signing in there, and iCloud Mail, Fastmail or any other mail server with an app password, as many mailboxes as you have: All inboxes holds them together, and each keeps its own folders and labels. Your mail is yours alone — the people who run your organizations cannot read it.

Read, search, archive, snooze, label, reply, forward and write new mail, with Undo after Send. Pictures in a message stay held back until you ask, so a sender cannot tell you opened it. Create task files a thread as a task with its files, and replies that arrive later follow it onto the task; Start run runs it with a workflow. An invitation is answered from the message, and Yes puts it on your calendar. Rules in Settings ▸ Mail archive, label, file or run what arrives, as you.

The assistant reads the thread you have open, searches your mail and drafts replies — the composer says it drafted them — and nothing it proposes sends mail, answers an invitation or copies a thread into a task until you say yes.

On the iPhone, Mail is the envelope at the head of the drawer, with a dot when new mail came; it opens over the app, with the folders under its title and Create task, Add to a task and Start a run a press from any thread. On the iPad and the Mac, Mail is the first row at the foot of the sidebar: its column lists the folder and a thread opens in a tab, and ⌘6 opens it. On Android, Mail is the first button at the head of the drawer, with Compose to write and Create task and Start run under every thread's subject.

Search finds what is on the page, not just its name

Search settings now looks inside every page, not just at the page names. Type "font", "dark mode", "token" or "Slack" and the pages that have it are listed with the matching setting under each; open either to go to the page. On the Mac and the iPad the search covers all of Settings from wherever you type it: the project's pages, the organization's and your own. Searching for "Secrets" next to a project's settings used to find nothing.

The iPhone and Android apps have the same search at the top of Settings, with the project's, the organization's and your account's pages in one list of results and what matched on each underneath its name. On the web and in the desktop app, it sits at the top of the settings list, and a tracker or notifier you could add is found under its group, where clicking it starts adding one.

The same goes for the other lists, in every app. Runs are found by what they were asked to do and their branch; tasks on the board by their description; triggers by the title and prompt of the runs they start; shared instructions by their description and prompt; mini apps by their description; memory by what an entry says; and a tracker's projects by the line under each name. On the Mac and the iPad, ⌘K finds these too, after everything that matches by name.

One calendar for every organization, beside the inbox

On the web and in the desktop app, Calendar moved to the top bar beside the inbox. It is yours now rather than a project's: every organization you belong to on one calendar, each organization and each of its projects a calendar you show or hide in the column on the left, in a colour you can change. Your own events and the time you reserve for work sit together under Personal.

The calendar opens on the week. Drag on the hours to make an event and type its title straight away; it opens in a panel beside the grid, where you also choose the calendar it belongs to. Deadlines, milestones, cycles and runs open in the same panel, with the way to where they live. Overlapping meetings stay readable: one that starts later is laid over the one it interrupts. Drag a task from Unscheduled onto the hours to reserve time for it.

On the Mac and the iPad, Calendar is the row above Inbox at the foot of the sidebar, with the month and your calendars in the column beside the week; an event opens beside itself. On the iPhone, the calendar button sits beside the inbox in the drawer and opens on the day. Android follows next.

The assistant stands beside your work on the Mac and iPad

The assistant now has a column of its own to the right of your tabs. Show or hide it with the assistant button at the top right, after the split button, or with ⌘2. Chat and Conversations at its top switch between the conversation and the list. It replaces the Assistant row in the sidebar.

It knows what you have open beside it, whether that's a file, a document, a task, a run, the calendar, a dashboard or a settings page. "Make this shorter" or "move this to Friday" needs nothing more. A chip under the message box names the page. Press the chip to leave the page out of your next messages.

The assistant writes into Assets and opens it, and the calendar

Ask the assistant to write a brief, a spreadsheet or a slide deck into the Assets library and it stages the file as a commit, the way it already does in Code: text files, and Word, Excel and PowerPoint files it builds, with each document's change on the card before you approve it. Files stored with Git LFS stay in LFS.

It can also take you to a file or a folder in Assets, and to the project's or the organization's calendar, at a day when you name one.

Archive assistant conversations

Archive a conversation from its row — a swipe on the phone, a right-click on the Mac — and it leaves the assistant's list without being deleted, the way an archived run leaves the runs list. The archive button beside New conversation shows the conversations you've filed away, where each one still opens and can be unarchived or deleted. Saying something in an archived conversation brings it back on its own. A conversation the assistant is still answering in can't be archived until it finishes. Available in the iPhone, iPad and Mac apps.

Document comments use your Peractor identity

Comments, replies and suggested replacements automatically use your signed-in member name across the web, desktop and mobile editors. The Author field is removed, and authors already in imported files are preserved.

A calendar for project work and personal time

Project and organization calendars bring deadlines, milestones, cycles, trigger forecasts and run activity together in month, week, day and agenda views. Add timed or all-day events and personal work blocks, repeat them, choose the scope of a series edit, and receive reminders through your existing notification preferences.

Set a deadline, reserve work time or deliberately schedule execution through the normal guarded trigger system. Save calendar views, filter the layers, open the original work and export an authorized iCalendar range. The assistant stages calendar changes for approval.

Sturdier Office editing everywhere

Word files with new comments, replies or lists now open cleanly in Microsoft Word, and editing one paragraph leaves the rest of the document's formatting alone. Files you may only read stay read-only, presentations included. Pressing Backspace in a workbook's dialog no longer clears cells. Android keeps unsaved Office drafts when the phone rotates, and the Apple and Android apps recover a document if its renderer stops. Quick repeated slide commands, like pressing Bold twice or Move up twice, now each act on the slide as it is. Find, links and presenting behave the same on every device.

More usable Office controls on phones

Color palettes offer larger touch targets and scroll through every shade. Swipe rendered presentation pages and use the compact actions menu for notes, blank screen and pause. Web menus support keyboard navigation and restore focus. PPS and PPSX files open directly in the editable presentation workspace. Android documents and workbooks keep their canvas visible while opening and saving. Text color changes preserve mixed font sizes, Apple speaker notes retain rapid typing, and iPhone slide dragging no longer competes with thumbnail context menus. Office prompts now use the app’s native sheets and forms on Apple and Android, including sheet renaming and native delete confirmations.

Link files without leaving your document

Word's Link tool now opens a compact picker beside your selection. Search project files and existing links, or paste a web address or email. Choose with the keyboard, preserve the selected words, and edit or remove an existing link without changing its text.

A fuller document color palette

Text, highlight and fill controls now open an eighty-color shade grid across documents, spreadsheets and presentations. Apply a swatch in one click, keep recent custom colors, or open the custom picker for an exact hex value. Supported platforms also offer screen color sampling. Authored colors stay the same in light and dark appearance.

Numbers in the shared spreadsheet viewer

Numbers files now open locally in the shared spreadsheet grid, with table tabs, cell selection, copying, search and zoom. Both older XML and modern Numbers workbooks are supported. Files remain read-only and downloads retain their original bytes.

Neutral presentation controls

New slide uses the standard neutral button style. Selected slide outlines and drag insertion markers use neutral ink across clients.

Consistent file opening

All file readers share one small neutral loading indicator after a single delay. Fast files open without flashing a spinner; fetching, decoding and editor startup keep the same background and no longer show competing loading messages. Native document and spreadsheet canvases appear only after their themed content is ready.

Focused links in presentations

Insert and edit presentation links in a compact popover on desktop and a native dialog on phones. Website and email addresses are recognized automatically; selected addresses link directly. Editing or removing an existing link preserves the original text selection and nearby formatting. The full-width link toolbar row is removed.

Office editing built for phones

Word, spreadsheets and presentations share native phone editing controls, focused formatting sheets and keyboard shortcuts. Android workbooks now use native sheet navigation and Find and Replace. Spreadsheet touch handles select a range without overwriting cells, with the formula field within reach at the bottom. Presentations give more room to the slide, keep thumbnails below it in portrait and beside it in landscape, and open notes and contextual tools in native sheets. Editing zooms small slide text into view, and opening Format keeps the keyboard out of the way.

Shared find and replace in presentations

Presentations now use the same Find and Replace control as other editors: a compact floating card on desktop and the native bottom bar on phones. Search across slides with case, whole-word and regex options, step through exact matches, and replace one or all occurrences while preserving text formatting. The custom presentation search row is removed.

Steady table headers while scrolling on Mac

CSV and TSV column headings now keep a uniform background during fast horizontal scrolling, including the add-column control and unused header space. The header follows light and dark appearance consistently.

Drag slides into order

Reorder presentation slides by dragging their thumbnails; on phones, hold a thumbnail to lift it. An insertion line shows where the slide will land, including the start and end of the deck. The moved slide stays selected, and Undo/Redo restores the order in one step. Move commands remain available in each slide menu; web thumbnails also support Alt+Shift+arrow keys.

A document editor designed for phones

Documents now open in a readable flowing layout on phones instead of shrinking a printed page. A compact editing bar replaces the desktop menu rows. Native formatting sheets hold fonts, point size, colors and paragraph tools; Insert, Find and document actions remain easy to reach. Apple uses the shared Liquid Glass controls and Android uses native Material controls. Toggle View → Print layout to check printed pages; flowing layout keeps the document's paper size and margins intact.

Native floating controls for document and slide presentations

Presentation mode now uses the same native chrome as the file viewer: Liquid Glass controls on Mac, iPhone and iPad, Material controls on Android, and shared Peractor icon buttons on the web. Compact floating filename and page-count capsules replace the flat full-width bars. Notes, blank screen, pause, shortcuts and Close remain available by icon and keyboard.

One status-bar zoom menu for every file viewer

Click the zoom percentage in the status bar to choose Fit or a fixed percentage. Fit follows the available space while a chosen percentage stays fixed. Documents fit their page width, spreadsheets fit their used columns, and presentations fit the slide canvas. Presentations now use the shared status-bar control instead of a second picker in the canvas footer. Images, videos and other zoomable previews use the same menu.

One Office toolbar for presentations, documents and spreadsheets

Presentation editors now use the same compact Office menus and formatting controls as Word and spreadsheets. Font size supports typing, presets and minus/plus; emphasis, colors, lists and alignment share the familiar icons and spacing. Insert, Slide and Arrange organize slide tools, while File saves, exports and presents the current draft. Native toolbars move only controls that do not fit into More formatting with their icons. Visual decks open directly in their editing workspace.

Stable preview controls when switching files

Preview zoom and full-screen controls keep their place while the next file loads. The file’s size and format no longer jump across the status bar as image decoders become ready. Unavailable actions remain disabled until the preview can respond.

Present documents and slide decks full screen

Documents and presentations share an immersive presentation mode with controls that disappear when idle. Present the current Word draft, PDF pages or a Markdown report, navigate with arrow keys or Space, jump to a page by number, blank the screen with B and return with Escape. Slide decks retain their notes, timer, transitions and timed advance. The native apps keep the display awake while presenting, and closing returns to the same editor with unsaved edits intact.

Consistent controls for Word and workbooks

Word and spreadsheets now share Peractor's Office menus and compact formatting controls, including native Mac tools. Menu labels and chevrons share a continuous clickable area. Formatting bars follow Markdown's spacing, with a little more vertical padding, quieter value selectors and aligned letter icons. Type a font size directly, choose a preset, or adjust it with minus/plus controls. Cell tools use clearer border and merge icons. Word's toolbar now includes links, images and clear formatting. Line spacing uses a recognizable icon and named Single/Double choices. Mac toolbars move only tools that do not fit into More formatting, keeping their icons and selection state. Word dialogs have opaque panels, consistent padding and room to scroll. Word count joins the file's existing status line, a slim full-width ruler with small indent handles stays beneath the toolbar with measurements aligned to the page, and writable documents open directly for editing.

A rich writing workspace for Word documents

Word files now open ready to write, with continuous rich text in place of individual text fields. Format selected words, use headings and an outline, edit lists and tables, add links and comments, review suggested replacements, find and replace, and undo changes. Insert images at the cursor or paste them, resize and crop them, choose text wrapping and add alt text. Paper setup and an interactive paragraph ruler update the draft immediately. The workspace follows Peractor's controls and appearance on every client. Save, PDF export and print-layout preview include your current draft, while unrelated Word package content is retained.

New organizations reach every device

Creating an organization, accepting an invitation, or leaving or losing one now shows up at once on your other signed-in devices. An account with no organization yet moves straight into the first one made or joined elsewhere, and the organization switcher stays current everywhere, without a restart.

Signing up or signing in with an emailed code in the iOS and Mac apps now opens the app as soon as the code is confirmed, instead of leaving the code screen in place.

Restricted folders stay out of runs

Folders and files closed to some people are now left out of every run unless the person starting it includes them. A run start offers Include restricted folders, with only the ones you can open, and a workflow's phase can name them with include:. A run started by an API key or a trigger with permissions of its own includes what its list lets it open.

A run that leaves files out works on a copy Peractor hands it, with no history and no git credential, and Peractor pushes what it changed after checking every file. A change to a file whoever started the run can't edit stops it, and nothing is pushed. Such a run never goes to a paired machine that uses its own git login.

A run that worked with restricted files shows its transcript, changes and artifacts only to people who can open all of them. Everyone else sees its title and status, with "This run worked with files you can't open.", and only someone who can open them may approve its gate. Nothing of it is posted to chats or tracker issues. Mini apps and restarted previews leave restricted files out too.

A workbook workspace for spreadsheets

Spreadsheets now open in a full grid with a formatting toolbar, formula bar, range selection and sheet tabs across all clients. Copy and paste ranges, fill formulas, find and replace, resize rows and columns, freeze panes, merge cells and undo edits. Imported styles, numeric formats, dimensions and supported charts remain visible. One workspace opens ready to edit when file permissions allow it; read-only files keep the grid with editing disabled. There is no Preview/Edit mode switch. XLSX workbooks also open offline. The grid follows Peractor's light/dark appearance, uses shared controls, and keeps zoom in the file's existing status bar. On macOS, the workbook's menu row uses Liquid Glass; formatting follows the markdown editor's compact toolbar, with the shared floating find-and-replace card.

Permissions for API keys

An API key now holds permissions of its own, chosen in Settings → API keys from the same list a role uses, and a new key starts with none. You can give a key only what you hold yourself. A project or a folder closed to Everyone opens to a key only through a row in its name on the project's Access page, where keys and triggers now sit beside roles and people. See as… and Why? show what a key gets, and why.

Each request to the public API now names its project: project in the body of POST /api/v1/tasks, and ?project= on the rest. Keys made before today hold nothing until they are given permissions.

A trigger can be given a list of its own the same way, on its page, by people with Manage roles.

Choose what a connected app may do

Connecting an app over MCP, such as Claude Code, now asks what it may do: Read only, Do work (runs, tasks, planning and files, without managing anything) or Everything I can do, with every permission under Advanced. On every call the app may do what you ticked and what you hold at that moment, so taking a permission from you takes it from every app you connected. An app on Read only changes nothing at all. Settings → Connected apps shows what each app was given.

Apps connected before today hold no permissions: connect them again to choose.

Document modes keep your place

Switching between Preview and Edit content now keeps your place in Word documents, workbooks, presentations, OpenDocument files and RTF. Preview shows the unsaved draft and reuses unchanged results when you switch back.

Add and remove table rows

Click any blank cell beside the row plus in a table editor to add a row and start typing in that column. The plus stays visible for repeated additions. The row-number menu now deletes rows, with Undo to restore the draft and row space. These interactions work across the web and native apps.

Access to folders and files

A folder or a file can now have its own access, as a project can. Manage access… in its menu in Code, the wiki and Assets opens the same settings for just that folder or file: Full access, Can edit, Can view or No access for Everyone, a role or a person, or Allow, Inherit or Deny under Advanced, which is where Manage access on a folder is set. Close assets/secret/ to Everyone and open it to Release leads, and nobody else finds it in the tree, search, history, the wiki, Assets, memory, a run's changes or the assistant's answers; a commit whose files are all hidden from them reads "Changes to files you can't open". The Access page lists every folder and file with settings of its own, marks one gone from the repository Missing, and warns when another project on the same repository leaves open what this one closes.

A link to something you can't open now shows You don't have access to this, with Request access. The people who could let you in are told, and the request names only the link. They grant it from the project's Access page, and you are told and the link opens; or they decline it, and you can ask again the next day. See as… shows what Everyone, a role or a person gets at the organization, in a project or in a folder, with Why? beside each permission.

A public link to an asset now carries the person who made it, and stops working once they can no longer open or share the file.

Private projects

A project can now be private. Its new Access settings, on the web, the desktop app, the Mac, iPhone, iPad and Android, have a Private switch: turn it on and Everyone can no longer see the project, you stay in, and you choose who else gets in — roles and people, each with Full access, Can edit, Can view or No access, or permission by permission under Advanced, each one Allow, Inherit or Deny. The same settings work on a project that isn't private, so a role can manage runs in one project and only watch in another.

A project you can't see isn't there: it is left out of the project list, search, the timeline, dashboards, notifications and the Inbox, the assistant doesn't reach it, a link into it opens as though it didn't exist, the API answers 404 and chat apps are told it isn't found. A private project you can see has a lock beside its name. The owner and people with Administrator see every project.

Access is seen and changed only by people with Manage access in that project, who can't give anyone more than they hold there, and can't take their own Manage access away. An organization-wide API key can't reach a private project; a key made for the project can.

Roles and permissions

Admin and member are gone. An organization now has roles, made in Members → Roles on the web and the desktop app, and in Settings → Roles on the Mac, iPhone, iPad and Android: each a name and a colour, a set of permissions chosen from thirty-one — Manage secrets, Manage connectors, Start runs, Manage tasks and the rest — and the people who hold it. A person's permissions are everything their roles allow. Roles are ordered, and you can only change, give or take away roles below your own highest; holding a permission is not enough to hand it out, so nobody can give a role more than they have.

Every member holds Everyone, which starts out able to see projects, start runs, create tasks, plan, and read and edit files. Each organization has one owner, who can do everything, is the only one who can delete it, and hands it over from Members — it moves when the member offered it accepts. To make an admin role, make a role and give it Administrator.

Roles also replace user groups: gate approvers name roles (role:), comments can @mention a role, and dashboards, mini apps, buttons and monitor alerts can be shared with roles. Cancelling or restarting somebody else's run now takes Manage runs, and editing somebody else's comment Manage tasks. Using a secret in a workflow, monitor, button, trigger or connector takes Manage secrets as well, a pack's install takes what its workflows take, and moving a task into a status that starts its run takes Start runs.

Runs are started, stopped and answered in Peractor

Commands typed somewhere else no longer act on Peractor. @peractor run, task, stop and status in Slack, the /peractor commands in Discord, and @peractor fix on a pull request are gone — start, stop and request changes in Peractor, from any app, the assistant, or a coding agent connected over MCP.

A connected Slack channel turns every top-level post into a task, as an import like an issue from Linear: nothing runs in the poster's name. The Mention capture setting is gone with the commands it waited for — a channel that was set to it now captures every post as well, and runs them if Run Automation is on. When a run from Slack or Discord asks a question, its thread gets the question and a link to the run; the buttons that answered in the thread are gone.

For CI and scripts, POST /triggers/:source and PERACTOR_TRIGGER_SECRET are removed: use the public API with a key (POST /api/v1/tasks), or a trigger's own webhook. The public API's completion callbacks are no longer signed with that secret.

Commits name the person who made them

Until now every commit Peractor made was authored by the organization: a page saved in the wiki, a file in Code, a run's work. Now the author is the person — whoever saved it, or started the run — under their name and email, and the organization's identity from Settings → Git access is the committer. Every commit also ends with Co-authored-by: Peractor. A run nobody started, from a trigger or an API key, is still authored by the organization.

That setting is now called Committer on every app.

The organization's memory, where local tools can read it

A coding tool run on someone's own machine reads the repository, not Peractor — so it never saw the organization's memory. A project's memory page now offers admins Add the organization's memory: one commit, shown before it is made, copying the organization's entries into .peractor/memory/organization/, which the project's index links. When the organization's memory changes, the page says what changed and offers Update the copy. Nothing copies or updates it on its own, and Peractor's own runs always get the live memory.

The line Point AGENTS.md at memory adds is now just the pointer to .peractor/memory/INDEX.md.

More tools on the slide canvas

Slides now support character selection formatting, grouping and alignment, image cropping and replacement, and native tables with inline cell editing, row and column changes and merged cells. These edits stay in the PPTX. Attached connectors, paragraph lists and spacing, and text links join the canvas, alongside find-and-replace and editable linear gradient fills. Page sizes and slide transitions join the toolbar; presentation mode adds speaker notes, a timer, pause and blank-screen controls.

Memory that stays tidy

Saving a new memory entry that says what one already says — the same title, or most of the same words — now asks first: Supersede it, Edit it instead, or Save anyway. A proposal waiting in the queue says Looks like … when it repeats an entry, so whoever decides it knows.

When a memory's Always entries come to more than a run is sent in full, its page says by how much and which entries are listed instead. The new Memory upkeep pack has a Consolidate memory workflow that reads the whole memory and proposes merges, rewrites and retirements — run it by hand or on a schedule; every proposal waits for a person.

A project's memory page also offers to point AGENTS.md at memory: one commit, shown as a diff first, adding a line that sends a coding tool run outside Peractor to .peractor/memory/.

Runs can propose what they learned

A prompt step can now be marked May propose memory entries (proposeMemory: true). Its agent may then write entries for the project's memory — a rule the team holds to, a trap it fell into, how to build the thing — and when its turn ends Peractor files each as a proposal. Nothing reaches memory until an admin approves it; the step's card in the transcript says what it proposed and what became of each. A proposal Peractor can't take goes back to the agent once to fix, and the step carries on either way.

The public API reads memory and proposes to it: GET /api/v1/memory, GET /api/v1/memory/entry and POST /api/v1/memory/proposals. A key proposes and never approves.

Memory you can read, write and approve

Project and organization memory now has a page of its own — Settings → Memory in a project, and Memory among the organization's settings — on the web, the desktop app, iPhone, iPad, Mac and Android. Entries are grouped by kind: instructions, rules, practices, lessons, decisions, a glossary, maps, commands, gotchas, ownership and notes. Each kind has a form with the sections it needs, and any entry can be edited as markdown, superseded, retired, or confirmed Still true when its review date passes.

Admins write. Members propose: a proposal waits in the memory's queue, the organization's admins are told in the Inbox, and an admin approves it, edits it first, or rejects it with a reason the proposer reads.

The system prompt fields in Settings now point at Memory: the organization's instructions are its first entry, and each project's are its instructions entry. Nothing is committed into a repository for you — an admin's Commit to repository writes them to .peractor/memory/instructions.md when they choose. Agents receive exactly what they did before.

See which memory each agent was given

The organization's and the project's standing instructions now reach agents as memory: entries an agent is sent in full, and an index of the rest, which it can open from its workspace when one fits what it is doing. Nothing an agent is told changes while the instructions are all there is.

In a run's transcript, the Prompt card's Organization and Project layers now list each memory entry with how it reached the agent — sent in full, listed, or not sent because the organization's own entry of that name applies. What earlier steps of the same run worked out is now called Run notes, so the two are never confused.

Every instruction layer adds

A workflow's own systemPrompt used to replace the project's standing instructions for that workflow's runs — the one layer that overrode instead of adding. It is now read as the start of the workflow's basePrompt: runs of such a workflow receive the organization's and the project's instructions as well, and then the workflow's own. No app ever offered that field, so only workflows written by hand are affected. This is the first step toward project and organization memory, which the system prompts are becoming.

A run that plans its own tasks

A new workflow step, Plan tasks, has the agent break a goal — a spec, a big issue, an approved design — into tasks, with what blocks what. Peractor checks the plan, files the tasks under the run's task, and starts them the way it starts any task: one waiting on others starts when the last of them finishes.

By default the plan waits at the phase's gate, which offers Review plan: retitle a task, change its description or take one out, then approve and file it, request changes to have it planned again, or discard it and let the run move on. A step can instead file the tasks into triage, or file and start them at once. A plan made again updates the tasks it filed rather than adding copies, and lists any task it dropped for you to keep or cancel. Each filed task says which run planned it.

Create and edit Office files and diagrams

Peractor's own editors now support document formatting and review, images and PDF export; spreadsheet structure, live supported calculations, formatting, filtering, sorting and charts; a visual slide canvas with thumbnails, direct text editing, dragging/resizing, formatting, undo/redo, layouts, shapes, notes and presentation mode; and a canvas for basic draw.io SVG diagrams. Create files from blank or repository templates in Code, Assets and Wiki. Preview the current layout before saving, including charts and images. Conditional formulas calculate in the editor, filtered rows stay hidden during keyboard navigation, and Wiki lists uncommitted Office drafts.

Independent drafts use repository conflict choices and the configured Git identity. Reviews show logical document, cell, slide and shape changes. MCP and the assistant can prepare Office edits, and agent sandboxes include Python Office libraries and LibreOffice. Imported advanced features and unsupported formulas retain explicit compatibility limits.

Edit documents and spreadsheets

Code, Assets and Wiki now offer Edit content for CSV/TSV, Word documents, spreadsheets and presentation text on every client. Save keeps the original file format and follows the project's commit settings. Modern Office files retain their other content; legacy Office, OpenDocument and RTF use conversion and warn when layout may change. Editors use each client's view controls and menus, with aligned cell grids, labeled paragraphs, native save actions on phones, and confirmation before reverting edits.

More ways to close tabs

Tab menus on Mac, iPad and Code on the web now offer Close Tabs to the Left, Close Tabs to the Right, Close Saved Tabs and Close All Tabs, alongside closing one tab or all the others. Actions apply to the selected tab's reader and disable when there are no tabs to close.

Close Saved Tabs leaves unsaved work open. Other bulk closes use the existing save and discard prompts; cancelling leaves every tab open. Focus stays on the current tab when it survives, or returns to the most recently used tab that remains.

Edit and create Assets with an agent

Every Assets file now offers Edit with agent, and folders and the library's add controls offer Create with agent. Both open the usual New run form with an editable request naming the file or folder. Complete the request, choose a workflow with the tools you need, and follow its run through previews, revisions and review. The selected Assets branch stays the destination throughout the run.

Markdown and other text assets open in the existing editable source and preview screen. Generated PDFs, Office documents and other supported files can appear as run artifacts. Assets runs download the selected LFS source and retain LFS on writes.

Merge steps can resolve their own conflicts

A workflow's merge step has a new switch, Let the agent resolve conflicts. When the run's branch conflicts with main, Peractor merges main in, hands the conflicting files to the agent, then checks the result itself — no conflict marker left, and the phase's earlier checks green again — before it merges. If main moves again before the merge lands, it goes round once more. If the agent can't finish, the branch is left exactly as it was and the run stops for you, as before.

The pass appears in the run as its own card, "Resolved conflicts with main — 2 files", with what the agent changed. It's off by default, and works with squash and merge commits.

A merge that's refused now says why: a conflict, a branch that's behind, a protection rule or failing required checks, instead of a bare error code. A local repository no longer stays half merged after a conflicted merge.

Assets navigation and original-size media previews

The Assets outline now lists files as well as folders. A folder click folds its outline; a double-click opens its contents. On Mac and iPad, an existing Assets library tab comes forward, or a new one opens while your file tabs stay available.

Apple media previews use the standard playback controls without a duplicate Play button over the picture. Audio waveforms follow native Play and Pause.

Images and videos open at their original dimensions. Status-bar controls zoom the picture, reset it to 100%, and enter or exit full screen. Esc exits full screen while the surrounding player keeps room for its controls.

Context menus reach more rows and keep your place

Right-click library records, tasks, runs, dashboard widgets, conversations and notification cards to reach their existing actions. Row menus keep link and text copying, and keyboard users can open them with Shift+F10. Choosing an action no longer also opens the row.

The Windows and Linux app now has native editing, selected-text, link and image menus. On the Mac, Control-click on linked text opens the same menu as right-click. Links in prose have their own cursor and direct menu, and missing images keep their dashed placeholder outline.

Long runs, editors and reviews are much faster on every app

Watching a long run is far lighter on every app: a new event redraws only what changed instead of the whole transcript, and a phase change no longer downloads the run's full log again. The dashboard no longer downloads every run's history when it opens.

The code and markdown editors colour only the lines you change, so typing stays quick in long files — on the Mac a keystroke in a 10,000-line file went from about 200 ms to under 10. Writing a review comment with many files open, reading a long wiki page, opening a large file and following a streaming assistant reply are all much faster.

Fixed along the way: on iPhone, iPad and Mac a second edit to the same file could show the first edit's lines, and the web run page no longer shows a warning after you approve a gate or answer a question.

Open more Mac destinations in new tabs

Open in New Tab and Command-click now reach more places across the Mac app: library records, cycles, archived work, commit history, dashboard links, assets, and links within run and task details. The new tab comes forward and the original stays open.

Workflow and instruction links open their reading view. Opening a reading tab from Settings or a dashboard now displays the requested record.

Metrics in workflows, password recovery, and runs by member

Trigger and tag templates can read stored project and organization metrics. Miniapps can read them through their member grant. Metrics and reports written by runs now have known run secrets removed before transfer and checked again before they are stored.

After signing in with an email code, you have ten minutes to replace a forgotten password without entering it. Two-factor checks still apply, and changing the password signs out other devices.

Runs can be filtered by any member who started one in the current list, on every client. Former members remain identifiable by their recorded names.

The assistant talks like a voice assistant

Talking to the assistant hands-free, you now hear it as it works: its first sentence — often what it is about to do — the moment it is written, and the rest a sentence at a time, in replies written to be heard. When it proposes something, it says what it will do and asks whether to go ahead.

Talk over it and it stops, cancels what it was still doing, and listens. The voice is your device's best one for your language, or one you pick under Voice in Settings. An organization can pay for natural voices from OpenAI or ElevenLabs with its own key, under Organization settings → Voice, and everyone in it can choose one.

The assistant opens workflows, instructions and triggers

Ask the assistant to show me the deploy workflow and it takes you there: to a workflow, an instruction or a trigger, in a project's library or in your organization's. Links to them now open in the app on iPhone, iPad, Mac and Android, each on its own screen, the way they always opened in the dashboard.

A plan that stopped partway now reads Plan stopped in the conversation list, in red, instead of passing for an applied one. Questions about a project's code are answered sooner, because its checkout stays between messages instead of being laid out again for each one. And the SSH key field on the assistant's card is masked in every browser.

The assistant commits to your code and arranges your dashboards

Ask the assistant to fix the typo in the README and it proposes a commit: its card opens to the files it changes, and each file to its lines, with Open in Code beside them. A commit always waits for your yes, in Auto too, because CI runs what a commit says. If the branch is protected, nothing is committed, and the assistant offers the same commit on a new branch. It makes branches, and moves, deletes and describes files in the Assets library, the same way.

It reads what a commit changed, or how two branches differ, before answering what changed in the last commit? And it makes, changes and deletes dashboards — make a dashboard for Website with its failed runs. Deleting one, or choosing who reads one, waits for your yes; anything else applies itself in Auto. It can also open one of your organization's apps for you.

Talk to the assistant hands-free

While the assistant's message box is empty, Talk stands where Send does. Press it and just talk: it sends what you said when you pause, reads its answer aloud, and listens again. It reads the words of an answer, says that code, diagrams and tables are on screen, and reads a plan change by change before asking for your yes — so a yes said aloud is a yes to what you heard. Skip stops the voice; End, or saying stop or that's all, turns it off, and so do 30 quiet seconds.

You can start one from anywhere: Alt+Shift+Space (⌥⇧Space on a Mac) opens a new conversation already listening — from any app with the Mac and desktop apps, and while the page has focus on the web. On an iPhone, iPad or Mac, say Ask Peractor to Siri, or find it in Shortcuts and Spotlight; on Android, add the Ask Peractor tile to quick settings, or touch and hold the app's icon.

Secrets, connections, keys and deletes, finished from the conversation

Ask the assistant to set STRIPE_KEY for Acme, connect Linear, make an API key for Zapier or delete the Website project, and it puts a card in the conversation that you finish yourself, on your device. A secret, a git token or SSH key, or a machine's own credential is typed into a masked field and goes straight to where it is kept — never into the conversation. Connect opens the provider's own page, and the card says whether it took when you come back. A new API key, or the command to pair a machine, is shown once on the card, with Copy. A delete waits until you type the name.

These cards wait for you in Auto too, and saying yes does not do them. Only an organization's admins can finish them, as in Settings. Anything about how you sign in — your password, two-factor, your sessions, your email — the assistant leaves to you, and opens Sign-in for it.

In Auto, anything that would send what your organization holds somewhere new now waits for your yes too: pointing a project at a repository; changing where a connector, an MCP server, a monitor, a button or a custom agent sends, or the secret it sends; and giving a workflow a new secret or a new shell step. A git token you limit to one host now goes to that host alone.

The assistant takes you there

Ask the assistant to show me the failing run and the app opens it. It can open a run, a task, a file at its line, a wiki page, a dashboard or a settings page, and move you to another of your organizations. On the phones and the Mac it can also switch between light and dark. Signing out, or switching to another account signed in on the device, asks you first.

Only the device you asked from moves. With the conversation open on your Mac and your phone, asking on the Mac leaves the phone where it was. Links in its answers open in the app too, Android included; on an iPad or a Mac they open in a tab of their own, so the conversation stays open.

Links to code, wiki pages, dashboards and settings pages now open in the app wherever links to runs and tasks already do.

Ask the assistant anything your organization knows

The assistant now answers from your organization's own material. Ask where do we compute VAT? and it searches a read-only copy of the project's code, on its default branch or on a branch you name, and answers from what the code says. It also reads the project's wiki, the text of its Assets — text and markdown, Word, PowerPoint and Excel files, and PDFs — what each phase of a recently finished run said when it ended, and any run you mention by name.

Answers say where they came from: a file in your repository at its line, a wiki page, a task or a run. Where your Peractor has a public address, each one is a link to it.

It reads only inside the conversation's scope, and only what you can read yourself. The first question about a large repository can take a minute while its copy is prepared; the assistant says so and answers from everything else meanwhile.

Choose where the assistant can act, and let it act on its own

Every conversation with the assistant now has a scope: the organizations and projects it may change. It starts as the project you're looking at, and the chip at the top of the conversation widens or narrows it, on the web and the desktop app, the Mac, an iPad and both phones. A change outside the scope is never proposed, and the assistant can't widen its own scope without your yes.

Switch the mode beside the chip from Manual to Auto, and plans apply themselves as soon as the assistant finishes; the card stays as a receipt, marked Applied automatically. Deletes, removals and changes to who has access still wait for you, with the rows that held them marked Needs your yes. The choice is kept for your account on every device, and Manual is where everyone starts.

In either mode you can answer a waiting plan with a plain yes instead of pressing Apply, and the card reads Applied — you said yes. One plan can now file a task and start a run on it, and the assistant can look at what a plan did once it applied — what a sync brought in, the run it started — and tell you.

Code: the repository, any branch, on every device

Code is a new destination in every project with a repository: any branch, its whole tree, any file, its history, and two branches compared — on the web, the desktop app, the Mac, an iPad and both phones. It works the way VS Code does: an explorer with an icon for every common file type, tabs, Go to file, search across the branch, and a Changes list with one Commit button.

Edit, add, rename and delete files and folders, then commit them as one commit — or let a project commit as you finish, as the wiki can. Two people changing the same file are merged silently unless they changed the same lines, and a protected branch offers to commit to a new branch instead.

The same file tree now draws a ZIP archive's contents and a run's changed files, so all three look and fold the same. And a wiki page with a ======= heading can be committed again, and a file deleted from the wiki on a remote repository is deleted.

Sign in with an emailed code

Forgotten your password? Every sign-in form has Email me a sign-in code below the password: on the web and the desktop app, the Mac and both phones. A six-digit code goes to your address, and typing it back signs you in. With two-factor on, your authenticator's code is still asked for after it.

The web's sign-in page offered this before, and the link did nothing. Every address gets the same answer, so the form can't be used to find out who has an account: an address with no account gets an email that says so, and no code.

Create account now works the same way the other way round. Given an address that already has an account, it emails a code instead of opening the account on the spot. The email says the account is there, and the code signs you in to it, with your authenticator's code after it if two-factor is on. It used to sign straight in on the right password, past two-factor, and to tell anyone which addresses were taken.

Runners are now machines

One word for where work runs. The screen that lists the computers you paired was called Runners, while the machine picker and the pairing form already said machine. It is now Settings → Machines on the phones, the Mac and the dashboard, and every message that sent you there says so too.

The place most phases run has a name that says what it is: Peractor's machine pool, a fresh isolated container for each phase, marked "(default)" wherever you pick a machine. A paired machine's row reads Version 0.4.2 — update available, and the pool's row says online like any machine that is up.

Nothing you set up changes. Workflows keep their runner: key, paired machines keep their tokens and their install, and the guide is now Machines & isolation.

Show the assistant what you mean

The assistant takes files. Attach a screenshot, a log or a document to a message — the paperclip in the message box on the phones, the Mac and the dashboard — and it opens the file and looks at it before it answers. "Set up our board like this one" with a picture of the board is a whole request.

A file rides with your words rather than replacing them, and what is inside it is something you are showing the assistant, never an instruction to it. Files stay part of the conversation: each sits under the message that sent it, and a later message can ask about one you attached several turns ago.

Sharing works the same way. Share a screenshot from another app to Peractor and The assistant — ask about it takes it along with your question — it used to step aside whenever a share carried a file.

Ask the assistant to do it, not only to explain it

The assistant can now do what you can do on a screen. It used to set Peractor up — workflows, instructions, settings, a run to start — and could only describe the rest: it would tell you a run was waiting for your review and leave you to go and find it. Now ask it to approve or reject a gate, answer a run's question, request changes, restart a phase or cancel; to file, triage, merge, relate or archive tasks, or change a dozen at once; to move a milestone and post its update; to sync a tracker or start an import; to invite people, look after machines and apps, or publish a pack.

It still proposes and you still apply. Each of these is a line on the plan it hands you, applied through the same code your own screens use, so it can do nothing you could not. On the phones and the Mac, a plan that is only an answer to a run's question — or a message to a step you are talking to — is a single Send button with the words beside it, because typing an answer and then approving a card that sends it was two yeses for one thing.

What it will not do is a short list, kept on purpose: delete an organization or a project, connect a service whose consent screen a person has to see, change how you sign in, or learn a secret.

Who filed it, what it is, and who has it

A task can have several people on it — up to ten, which is GitHub's limit for GitHub's reason: a task assigned to everybody is assigned to nobody. Each person added is told. On a board grouped by person a task with two people stands in both columns, and dragging it into a third column hands it over. Synced GitHub and GitLab issues now bring every assignee, where they used to keep the first and drop the rest without saying so.

My tasks knows who you are. It matched on a name, so renaming your GitHub login took your own tasks off your own view. It matches your account now, and a name only where there is no account to match — an imported issue assigned to somebody who never joined.

A task says who filed it, set once when it is made. A synced issue carries its tracker's reporter, and a backlog imported from Linear, Jira, GitHub, GitLab or Notion keeps every issue's reporter instead of crediting the import.

And it can say what kind of thing it is. Your project names its own types — Bug, Feature, Chore, whatever your team calls them — each with an icon and a colour, under Types beside Statuses and Priorities, and every task wears its type's icon beside its title on the board. Change a task's type on the task itself or a dozen at once, and group a board by type or by who filed it. A project that defines none has no type field anywhere: nobody meets a concept their team did not ask for. An import brings the source's types with it, so a Jira project arrives with its Bug, Story and Epic as your own.

Publish from any device, as your organization

Publishing a pack works everywhere now — the phones and the Mac as well as the dashboard. Publish a pack sits in the marketplace, and the form is the same decision on each: pick what goes in, name it, say what changed.

The organization publishes, not whoever pressed the button. A pack wears your organization's name and picture, and any of its admins can publish the next version — a pack should not become unmaintainable the day one person leaves. The form offers every library the organization has at once, the shared one and each project's, and says which is which: "Release" in the shared library and "Release" in a project are two different workflows.

What a workflow uses comes with it. Tick a workflow and the instructions its steps name are ticked beside it, each saying which workflow holds it, and one a picked workflow still needs cannot be unticked. Anything that only means something inside your organization — the statuses a phase moves a task to, a notifier you named — is left out of the pack, and the form says so before you press Publish rather than after somebody installs it.

Your own packs come first, under "Published by" your organization's name, withdrawn ones included. Each has Publish a new version, which starts from everything the last version carried, and Unpublish, which takes it off the marketplace and refuses new installs without touching anybody who already installed it.

And a pack lands where you opened it from. Open the marketplace from a project's skills and the pack installs into that project; from the organization's library, into the organization's. The page says which above the button. Packs mix kinds now too: most of ours carry skills beside their workflows and instructions.

Videos play where they were attached

A video attached to a task or a comment now plays right there, in each device's own player — on the phones, the Mac, the dashboard and the desktop app. Until now the viewer wrote the file's name on a black screen and suggested finding a computer, on the one device already holding the clip.

Nothing starts playing by itself. A format the device cannot play says so and names the type, instead of drawing a black rectangle and failing where nobody sees it. And the copies a phone keeps in order to play them are cleared when you sign out, so the next account on that phone finds none of yours.

Your project decides where things are

Runs, Triggers, Tasks, Planning, Wiki, Apps and Settings, in the order your team wants them. A phone's tab bar holds five things and this product has seven, so something was always off the bar — and we picked which, badly: turning a wiki on quietly took the Triggers tab away, and Planning had no door of its own at all.

Now an admin drags the list in Settings → Navigation, and every device follows: the phones, the iPad, the Mac and the dashboard. Whatever a phone's bar has no room for is behind More, which is a screen rather than a disappearance — nothing here can hide a part of the app from the people using it.

A team that lives in its wiki drags it to the front. A team whose work all starts from events puts Triggers first. A project that never opens the screen keeps the order we think is right, and gets our next answer for free when we change our minds.

On the Mac, all six of a project's destinations are rows in the rail — Triggers and Planning were filed under Settings and inside the board before this, which made them the two the order had nothing to say about. Each opens the desk's own three columns: your triggers beside the one you are editing, your cycles and milestones beside the one you opened.

Your team's notes live in the repository

A project can have a wiki, and the wiki is markdown files in your own repository. Not rows in our database. Turn it on, name the folders that hold pages — docs/ is prefilled — and every markdown file under them is a page on every device: the phone, the browser, the Mac, the desktop app.

Every client holds the whole wiki as text, so it opens instantly and searches with no connection at all. Edit on a train; a pending list shows what this device has changed, and one button commits all of it in a single commit. If somebody edited a different part of the same page while you were offline, the two merge and nobody is told anything — you are only asked when you both changed the same lines.

Because the pages are the repository, the agent working your next run already has them, they are diffed and reviewed like the code they describe, and a developer editing docs/ in their editor is simply editing the wiki.

Look at a preview on your phone, and draw on it

A run that parks with a preview now opens inside the phone app rather than throwing you into a browser. Look at the real thing, then continue or request changes without leaving the run.

And you can draw on what you are looking at — circle the misaligned button, scribble on the broken row — and the drawing goes into the note the agent receives. A pointed finger beats a paragraph describing where to point.

The backlog becomes a real tracker

Every task gets a key — WEB-14 — that names its branch, prefixes its pull request, and finds it in search.

A conversation and a record. Comment on a task, reply once, attach files, and name people with @. Every change writes a line, so a task reads months later. Runs comment too: a run posts when it starts, when it parks for review, and when it settles, each comment a door into the transcript.

Planning. Milestones with dates and progress, cycles on a cadence you set that roll unfinished work forward by themselves, and a triage queue that holds work arriving from outside until somebody says it is real. Plus sub-tasks, relations — blocks, blocked by, relates, duplicates — estimates on the scale your project uses, and due dates.

Views. Filter, group, order, and switch between a board and a list, then save the arrangement. Active, Backlog, My tasks, and Current cycle are always there. Drag to reorder or to change column, and change many tasks at once.

And a way off your old tracker. Import a whole Linear team, Jira project, repository, Notion database, or Slack channel — comments, attachments, dates, parents, relations and all — into tasks Peractor owns. You read the plan before anything is written, it can be run twice safely, and nothing is ever written back to the source.

Open a run's file where you actually work

A file a run changed now opens at its first changed line, in your own editor — VS Code and its forks, JetBrains, Xcode, Zed, and a dozen more. The picker lists what is installed on your machine and remembers what you chose.

A pull request is a piece of work, with a board

Incoming pull requests become tasks. The third GitHub tracker, on the same app install as Issues and Projects, with six columns instead of two — Draft, Open, Changes requested, Approved, Merged, Closed.

A run started from one is a review run: it checks out the pull request's head, diffs against its own base, is told it is reviewing and who wrote the code, and writes nothing at all to the repository. What it finds arrives as a comment on the pull request.

Moving a card can close, draft, reopen or mark ready. It refuses Approved, Changes requested and Merged, and says so — the first two are a person's judgment, and the third would merge somebody's code because a card moved.

Steps that wear several roles, loops that reach back a phase

A step can bind several instructions. A step is regularly a frontend engineer and the house reviewer, and writing a third instruction that repeats both is how a library stops being reusable.

A loop can reach back into an earlier phase — "if the checks in Verify failed, go back to Build's implement step and do it again" — and can now exit when either condition is met rather than always needing both.

A tag step really cuts the tag, from a template you write, on the base branch as it stands when the step runs. And git steps can skip what is already done, so a re-run phase stops failing on the one step with nothing left to do.

A step's conclusions carry forward by default. Every prompt step is a fresh session, so what one worked out used to vanish unless it was committed. Now it ends with a short note that every later step receives — switch it off per step if the thinking is not worth passing on.

And your organization's standing instructions wrap every run. Four layers, each openable on its own in the transcript: the organization's, the project's, the workflow's, and the step's instruction.

Steps you can talk to

Mark a prompt step interactive and it runs its prompt, then stops and waits for a person. Until somebody ends it, anyone who can see the run can open the step and talk to the same agent — send messages, read replies, watch the tools it uses. The conversation is part of the run and shows in both places.

Two ways out: Proceed accepts and advances, and Request changes re-runs the phase with the conversation threaded into the next prompt — because a conversation that concludes "this approach is wrong" should not strand you.

It costs nothing while nobody is in it. Peractor keeps the machine warm for a short window, then saves the work and gives the machine back, with the decision still open. More than one person can be in one conversation.

Skills your agents carry, and MCP servers they may call

Teach every run how your organization works. A skill is a page of instructions with one line saying when it applies — written once in your organization's settings, staged on disk for every run of the projects that pick it, and followed by the agent when the work matches. Skills use the open SKILL.md format, so the ecosystem's public skills work here: paste a GitHub address to import one, or start from the suggestions on the empty screen.

And hand your agents the tools you already run. Register an MCP server — a docs index, a database gateway, an internal API — and every run of the projects that pick it can call its tools, on Claude and Codex alike. The token is stored encrypted, referenced by the run's environment, and never written to any file the agent could commit; registering and changing a server is admin-only and lands in the audit log. If you harden egress, a registered server's host joins the allowlist by itself.

Picking stays the boundary. Like shared workflows and instructions, a skill or a server an admin registers does nothing anywhere until a project ticks it under Settings → Shared library.

Previews you can come back to

A preview waits for you now. It used to hold the run's machine open while it waited, and give up after half an hour — so a site built overnight was a dead link by morning, and the only way to see the finished work was to run the phase again. The run parks instead: the decision stays open for as long as it takes, and nothing continues without you.

Tell the preview step how to serve what it built — npx serve -s dist -l $PORT, with an optional folder and build line beside it, the same three fields an app declares itself with — and Start preview brings it back from the very commit you are being asked about. The build log runs while it comes up, so a two-minute wait reads as work rather than a hang.

One preview, everyone looking at it. Two people reviewing the same result share one container and each other's link, and the card says when somebody else is on it. It stops when the last of you does — a preview nobody is reading costs nothing, and starting it again is a button. A preview step with no serve line still shows you the result while its phase is up, and the run still waits for your decision afterwards — it just cannot be started again.

For self-hosters: previews are sized against your box with PERACTOR_PREVIEW_MAX_RUNNING and friends, and the review window is gone — there is nothing to time out.

One link for everything, and a share sheet that files work

Every run, task, workflow, instruction, trigger, app, and project has one link. It opens the right thing on whatever the person opening it is using — the app where it is installed, the browser otherwise — and it carries enough to open cleanly even on a device signed in as several people. A link to a gate lands you on that gate.

And it works the other way: Peractor is a share target on iPhone, iPad, Android, and the Mac. Share a screenshot from anywhere and pick where it goes — a run, a task, or a message to the assistant — with the file attached. "Here is the bug" is a screenshot and a sentence.

A marketplace of workflows and instructions

Install a set of workflows and instructions somebody already wrote. Open the Marketplace, pick a pack, and everything lands in your organization's shared library under a category named after it. From that moment the copies are yours — edit them, rename them, delete them. Nothing stays owned by the marketplace and nothing ever changes on its own. Packs are free; there is no paid tier and no cut.

The install screen is the point. Installing a pack means running a stranger's instructions on your infrastructure with your credentials, so before you press the button you see every step it would add — drawn in Peractor's own vocabulary rather than the author's description, so a step that runs a shell command or posts to one of your connectors says so — what it needs that you do not have, and what the checks found. A pack that runs shell commands asks twice.

Updates wait for you, and never overwrite your edits. When an author publishes a new version your list says so; Update shows what would be rewritten and the changelog for every version between yours and the new one, not just the newest. Anything you have changed is recognised as yours and skipped — editing one workflow does not cost you fixes to the other nine — and a version that drops a record deletes nothing.

Publishing closes over what you picked: a workflow brings the instructions and prompt files its steps name, or the publish is refused rather than shipped broken. Every version is scanned first — no web addresses in text an agent will read, no command that downloads or escalates or reads your credentials, no secrets in prompts — and a version that fails is not published at all. The badge says "checked", not "safe": an automated scan cannot promise the second one.

Apps your organization builds for itself

A small web app, built from your repo, opened from every device. A team chat, a retro board, a poll, a dashboard: declare it from Apps, point it at a folder in a repository, and an admin deploys it. It appears in the Apps list on the dashboard, in the desktop app and on both phones — where it is a tab of its own, and an open app fills the screen with no chrome around it.

Nobody signs in to it. Whoever opens it is already themselves, and Peractor stamps who they are onto every request it forwards, after stripping anything the browser sent under the same names. The app never sees a password, a token or an email address — and it never asks.

It can reach nothing. The container has no route to the internet or to your network; the only thing that can talk to it is Peractor, forwarding the people who opened it. An app cannot leak what it is told, which is what makes it safe to tell it who is in the room. It starts when somebody opens it and stops when nobody has for ten minutes, so an app nobody is using costs nothing.

Deploys are ordinary and reversible. Build a branch from the app's own screen; people get the new code on their next page load and whatever the app stored is untouched. Every build keeps its log, the last three keep their code, and Make live is an instant rollback — no rebuild, nobody signed out. Data lives on one volume that outlives every deploy and every rollback.

Your account, and every way into it

A confirmed email address is your account. A password, a GitHub login, a Google account, a Linear user — each is a way in, and one account can hold as many as you like. Sign up with Google, add a password later, attach GitHub because a teammate's approver rule names it, drop Linear when you stop using Linear. You land on the same account every time.

A Sign-in methods screen on every surface lets you add and remove providers, set or change a password, change your email address, and see the devices signed in as you — ending one, or all but this one. The last way in is refused before it is offered rather than after.

Two-factor authentication with an authenticator app, and several accounts signed in on one device: switching is instant, nothing signs out, and each account keeps its own notifications and cached work.

Run on your own machine

Pair your Mac or Linux box and run phases on it — for the work the Peractor runner can't do: building and screenshotting a native app, driving the iOS or Android simulator, using a toolchain or GPU only your machine has. The machine runs a small agent that dials out to Peractor over one WebSocket; nothing ever connects to it, so home NAT with no public address works with no port forwarding and no tunnel service. Pair in Settings → Machines, label the machine (say macos), and any workflow phase with that label — pickable in every editor's Runs on field — executes there. Every phase header says where it ran.

The whole run experience crosses over: screenshots and other artifacts the agent registers arrive inline in the run, and preview steps serve from the machine too — the built result stays on the machine's own localhost while its traffic rides the same outbound connection, so reviewers use the normal preview link and the machine's network sees nothing.

Sign-in is per machine: save a Claude/Codex key or subscription token for each machine in Settings, or just sign the machine itself in — your organization's key from Model providers backs the Peractor runner and is never sent to anyone's laptop. Pairing, removal, and machine sign-in are on the web, the desktop app, and both phones.

The phones work without a connection, and runs can be filed away

A phone gets used in lifts, trains, basements and planes. Now the last answer each screen received is kept on the device and drawn on the first frame of the next visit, marked as a saved copy, while the fresh one loads. You see what you had instead of a spinner.

And any finished run can be archived: it leaves the runs list for an archive of its own and comes back with one action. The runs list answers one question — is anything waiting on me — and this is how it keeps answering it after the three hundredth run.

Work that starts itself

Triggers bind an event to a workflow run, so a run no longer needs somebody to click it. Three sources, one config file: a schedule (a 5-field cron, UTC), a repository event (a push, a tag, a pull request opened, updated or closed — through the GitHub App already installed, filtered by branch and by changed path), and a webhook anything that can POST JSON can call, signed with a secret from your organization's store.

The event reaches the agent as text: the run's title and description are {{ event.pr.number }}-style templates over the payload, with {{ event | json }} for everything a normalized event doesn't name.

Because a triggered run spends money without being asked, every evaluation is recorded — fired or not — with the guard that decided it in a sentence you can act on: disabled, a filter that missed, Peractor's own commit, the concurrency policy, your quota, a repeat delivery. A Test button shows what would happen without starting anything, and Run now fires it for real. Triggered runs carry their attribution in the run header and group under Triggered in the runs list.

Triggers are a library beside Workflows and Instructions — in the dashboard, the desktop app, and on both phones.

Run whole workflows side by side

A phase can fan out into lanes, each running another of your project's workflows at the same time, in its own container on its own branch. Ship the same feature on Android and iOS; try three approaches; run a security audit beside the implementation.

When the lanes settle, the next step gets every lane branch fetched locally — so git diff and merge between them just work — plus a manifest and a report per lane. Gates, questions and previews are honoured per lane: one that needs you parks on its own while its siblings carry on.

With a single lane it is not parallelism at all but reuse — one shared test-pass workflow dropped into ten pipelines instead of copy-pasted phases.

An assistant that sets Peractor up for you

Describe your team and what you are building, and the assistant drafts the workflows, instructions and settings that match — then shows you exactly what it would change and waits.

It proposes; you apply. It works in a throwaway copy of your configuration, so nothing it writes is your configuration. A turn ends with a plan you read and either approve or discard, applied all at once through the same handlers your own screens use — so it can only ever do what you could do. It never learns your secrets, and a draft with a credential written into it is refused.

It reaches every organization and project you belong to, needs neither to get started, and answers questions about how Peractor itself works.

Peractor on your phone, and on your desk

Two new apps, both running the same screens as the dashboard rather than a reduced version of it.

Peractor for iOS and Android puts a run in your pocket: the live transcript as it streams, gates to approve or reject, mid-run questions to answer, the diff to review, the backlog to work from, and push notifications when a run parks for review, asks something, or ends. Peractor for desktop is a native window with the session in your OS keychain and real system notifications.

The web dashboard became a single-page app in the same pass, so switching runs, gates and tasks no longer reloads the page.

Attachments, a public API, and artifacts you can look at

Tracker attachments now reach the agent — the screenshot on the Linear issue is part of the task, not context you have to retype.

Organizations can mint API keys, so your own software can register a task and start a run on the org's behalf without a browser anywhere in the loop.

Artifacts a run publishes are rendered rather than listed — an HTML widget, a chart, a diagram, a screenshot. Each opens in a tab of its own, sandboxed with no network at all, so you can look at what the agent built while it is still building.

Run one task across several agents at once

Parallel runs: send the same task to several agents at the same time, each with its own model override, and compare what comes back. The siblings group under one parent in the runs tree instead of scattering.

Presets save the run configuration you keep retyping — agent, model, workflow — as one pick.

Live previews, questions mid-run, and Slack as a task source

A preview step holds the run open and serves what the run built at its own URL, so you review a running app instead of a diff. A per-run warm workspace keeps the clone and its dependencies across the phases of one run, which is most of the wait gone.

Agents can now ask you something mid-run: the run parks, the question reaches every surface you're signed in on, and your answer resumes it — no more guessing wrong for twenty minutes.

Slack joins the trackers as a chat-native task source: a message becomes a task, reactions move its status. And a finished run takes requested changes as rework.

Projects, onboarding, and config that lives with the org

Projects are a first-class tier between an organization and a repository: workflows, instructions, connectors and settings belong to a project, and a repo binds to one with a small peractorrc.json. Configuration moved into the org's own storage, so a teammate who clones the repo inherits the setup instead of rebuilding it.

New organizations get a real onboarding — create or join an org, invite the team by email, and a staged setup wizard that connects a tracker, a workflow and a notifier before the first run. Slack also became a one-click OAuth notifier.

GitLab and Notion join the tracker lineup

Two new first-class trackers, both connected with one OAuth click — no API keys to paste.

GitLab imports issues per project and syncs status through labels, alongside the existing merge-request support. Notion imports any database as a backlog: a per-database property picker maps your status, assignee, and label properties onto Peractor's board, so pages move columns as runs progress.

Instructions, published artifacts, and GitHub Projects

Instructions are reusable guidance — a name, icon, color, and prompt kept in instruction/ — that any prompt step can carry. Your spec step and your implementation step no longer have to be told the same things in every workflow.

Phases can now publish design artifacts: the agent renders previews of what it built (screens, diagrams) and Peractor delivers them to your review surfaces — the gate, Slack, the tracker.

GitHub Projects (v2) boards are a tracker of their own, with real status columns — where plain repo issues only know open and closed.

Accounts, organizations, and the web app

Peractor is now multi-tenant: sign up with email, GitHub, or Linear; create an organization; invite your team with a link. Admins manage members and roles from the web, and every run, task, and connector is scoped to its org.

Tracker boards now mirror the real task board — including tasks currently owned by a run.

The task board goes first-class

The backlog now holds tasks from multiple trackers and manual tasks at once, each keeping its origin, priority, assignee, and labels. Imported issues route to a workflow by label/assignee rules you edit next to the tracker.

Code review shipped alongside: leave review comments on a run's diff and submit them as a "request changes" rework — any time, not just at a gate.

Peractor's source also went public under the MIT license.

Draft PRs and a sharper live view

Runs open a draft pull request when work starts and mark it ready as it lands; branches derive from the task, so a run's history reads like a teammate's. The live session shows the exact prompt each phase sent, friendlier markers for git steps, per-phase model and reasoning-effort chips, and one-click checkout of the committed branch.

Webhook sync and per-origin statuses

Trackers push changes in over webhooks, so imported tasks stay live without polling delays — and can auto-start a run on arrival (opt-in). Statuses became per-origin: each tracker's own columns sync natively, with no translation table, and workflow phases can reference them in status automation.

Status-driven workflows

A workflow phase can declare onStatus — the board column that triggers it — and setStatus — where the task moves when the phase lands. Drag a task to "In Progress" and the right phase starts; when it finishes, the card moves on. The board becomes the control surface.