This release is about not losing things. Press one shortcut and DorkOS finds any message anyone ever said — in your channels and in every Claude Code, Codex and OpenCode conversation on your machine. Your agents stop forgetting, too: each one keeps a small notes file it reads before every turn. And scheduled tasks became something simpler than they were — an ordinary skill with a time on it.

Highlights

Find any message by what was said in it

Press ⌘⇧F (Ctrl+Shift+F on Windows and Linux) and type what you half-remember somebody saying. DorkOS searches your channels, your direct messages, and every Claude Code, Codex and OpenCode conversation — including ones you had in a plain terminal, outside DorkOS — then takes you to the exact line that said it.

It only ever reads what was said. Command output, file contents and an agent's private notes stay out, so a search fills up with sentences instead of machine noise.

Your agents remember what they learn

Every agent now keeps a short notes file beside its instructions. It reads those notes at the start of every conversation and writes down what is worth keeping — so telling an agent something in a private chat means it still knows in a team channel next week.

The file is plain markdown you can open from the agent's profile. Fix a line to correct it, delete a line to forget it. Every note records where it was learned, so a note that turns out to be wrong tells you which conversation taught it.

Scheduled tasks are just skills with a time on them

Add a schedule: block to any skill and DorkOS picks it up — no special folder, no moving files. Take the block out and it goes back to being an ordinary skill. Your existing tasks move themselves across the first time you start this version, approvals intact.

Nothing found in a file ever starts running on its own: a schedule waits on the Schedules page until you approve it, so one can never arrive through a git pull and quietly start working. New this release, a task can also be sticky — every run resumes the same conversation, so your agent can say "since I last ran, here's what changed."

See it in motion on dorkos.ai/features.

Ten new comparison pages, and plainer ones everywhere

dorkos.ai/compare now covers the runtimes DorkOS drives and the tools people keep asking about — Agent HQ, Devin, Conductor, Claude Squad, Omnara, Amp, Cline, Droid, Grok Bot and more. Every page leads with what the other tool is genuinely good at, links each claim to the maker's own page, and says plainly where the other tool beats us.

All Changes

Added

Three new pages at dorkos.ai/compare cover the coding agents DorkOS runs for you: Claude Code, Codex and OpenCode. These are not head to head pages. Each one says what the agent already does well on its own, then what having DorkOS around it adds, so you can see where the line sits before you install anything (DOR-1465)
Each page scores the agent honestly on its own merits, with a link to the maker's own documentation behind every claim and the date someone last checked it. Where an agent already does something DorkOS does, the page says so instead of quietly leaving it out (DOR-1465)
When the desktop app misbehaves, Help → Save Diagnostic Report now gathers everything we need to help you into a single file on your Desktop: the app's logs, your version numbers, where the app is installed, and what its last update did. Your saved keys and passwords are replaced with [redacted]. The logs go in as-is, so glance through them if you're unsure about anything in there. The same item is in the DorkOS menu on your menu bar, which still works when the window itself won't open. The logs now also record the moment DorkOS first reaches its own server, so "it opened but nothing loaded" is a question the file can actually answer (DOR-1456)
A skill file can now carry a schedule: block that says when it should run: a time, a timezone, a time limit, how much the run may do on its own, and what to send when it fires. DorkOS understands the block today. Actually running a skill from its own schedule: block arrives in a later change (DOR-1484)
A task that could not run because DorkOS was already at its limit now says so in that task's history, at the time it was meant to run, instead of disappearing without a word. It shows as "Skipped", with the reason, and it does not count against the task's success record (DOR-1482)
Five new pages at dorkos.ai/compare put DorkOS head to head with the tools people ask about most: GitHub's Agent HQ, Devin, Conductor, Emdash and Claude Squad. Each one says what the other tool is genuinely good at before it says anything about ours, and every claim links to the maker's own page with the date someone last checked it (DOR-1466)
The Conductor page settles which Conductor it means in its first sentence, and again further down. Three different products share the name, and only one of them is the Mac app for running coding agents (DOR-1466)
Where a rival does something better, the pages say so plainly. Emdash drives more agent tools than DorkOS does and can also run jobs on a schedule; Agent HQ reaches more screens and hands one job to three companies' agents at once; Devin can split a job across copies of itself. Those are all in the tables, in their column, marked done (DOR-1466)
Five more pages at dorkos.ai/compare, covering Omnara, Amp, Cline, Factory's Droid and DeepSeek Harness. Each one leads with what the other tool is genuinely good at, and every claim links to the maker's own page with the date someone last checked it (DOR-1467)
The DeepSeek Harness page is the one to read if you want to know who else is building what we are building. It runs Claude Code and Codex inside itself, which is our own headline trick, so its column is marked done exactly where ours is. We quote its makers calling it a developer preview instead of softening it, because that is how we would want our own early parts described (DOR-1467)
Where a rival is ahead, the tables say so plainly. Cline runs jobs on a cron line and already has agent teams with a shared task board and a mailbox, which is further than our rooms have got. Droid schedules work and plans big jobs into milestones that get checked. Omnara ships an iPhone app with an Apple Watch app beside it, and we ship neither (DOR-1467)
Two things worth knowing if you read about these tools elsewhere: Amp is no longer Sourcegraph's agent, having spun out into its own company at the end of 2025, and Omnara has moved on from being a phone command centre to being a platform for running agents. Both pages say so in their first few lines (DOR-1467)
Five more pages at dorkos.ai/compare. Three are for tools that are not really our rivals but keep coming up next to us: OpenClaw, Hermes Agent and Block's Buzz. Each one opens by saying plainly that it is a different kind of product, and then compares only the ground the two actually share (DOR-1468)
Two are for tools that no longer exist: Terragon, which closed in February 2026, and Roo Code, which closed in May. These pages are for people trying to work out where to go next, so they lead with what happened rather than with us, and both say out loud where DorkOS is the wrong answer. The Roo Code page says it plainly: if what you miss is the agent inside your editor, the tools its own team named will serve you better than we will (DOR-1468)
The Roo Code page corrects something most write-ups get wrong. Roo Code's own shutdown notice names two alternatives, Cline and ZooCode, and Kilo Code is not one of them, however often you see it called the official replacement. The page says who named whom, so you can choose on the facts (DOR-1468)
The Buzz page is the one to read if you want to know where someone else is ahead of us. Buzz can hand an agent a new instruction while it is still working, and our rooms make you wait for the turn to end. It says so in the table, twice (DOR-1468)
Where a fact could not be checked, the pages say so instead of guessing. Terragon's shutdown notice went offline with its website, so that page explains where the notice went, links an archived copy, and quotes no prices we could not confirm (DOR-1468)
Compare is now in the menu at the bottom of dorkos.ai, right after Features. The comparison pages have been there for a while, but you had to already know they existed, or find the link in the footer (DOR-1504)
The menu now shows you where you are. Reading a comparison, Compare is the word that stands out; reading a feature page, it is Features (DOR-1504)
The Compare page opens with a picture of DorkOS instead of only words, so you can see the thing being compared before you read about it (DOR-1504)
A new page at dorkos.ai/compare for Grok Bot, xAI's cloud coworker. It is not the same kind of tool as DorkOS, so the page says that first and then compares only the ground the two share: work that carries on while you are away, and checking in from your phone (DOR-1514)
The page answers the question the pricing pages make hard work. Grok Bot does not come with every Grok or Cursor plan: xAI lists SuperGrok Plus and SuperGrok Heavy, and on the Cursor side Pro+, Ultra and Teams. Plain SuperGrok at $30 and Cursor Pro at $20 are not on that list, and the page says so with the current numbers (DOR-1514)
It is honest about the row where Grok Bot is ahead of us. Several of its bots run at once, message each other and hand a job along, and that works today, while our rooms are still marked early (DOR-1514)
It is also clear about what Grok Bot is not for. The eight jobs xAI uses to describe it are office work: outreach, recruiting, expenses, a weekly report. Working through the code in your own repository is not one of them (DOR-1514)
Marketplace packages can ship scheduled tasks. Until now only a Shape could set one up; a plugin, agent template, or skill pack can now do it too, so a package that does recurring work brings its own schedule instead of leaving you to write one by hand after installing. (DOR-1487)
A package sets up a schedule in one of two ways: it points at a skill it already ships, which puts the timing right in that skill's own file, or it describes the work itself, which creates a new skill for it. Either way you end up with a normal skill file you can read, edit, or delete. (DOR-1487)
Before you install, the confirmation screen now lists the scheduled tasks any package will set up — not just a Shape's. It shows how often each one runs and what it is allowed to do while nobody is watching. (DOR-1487)
Removing a package removes the scheduled tasks it created. Nothing it set up keeps running once it is gone, and skills you wrote yourself are never touched. (DOR-1487)
Any skill can now be a scheduled task. Add a schedule: block to a skill's settings and DorkOS picks it up — no moving the file, no special folder. Take the block out and it goes back to being an ordinary skill. DorkOS watches your agents' .agents/skills/ folders and a new ~/.dork/skills/ folder for schedules that do not belong to any one project (DOR-1485)
Nothing DorkOS finds in a file ever starts running on its own. A schedule found on disk waits on the Schedules page until you approve it, whether or not the file says it is switched on. Once you approve it, it stays approved as long as the file does not change; edit what it does or when it runs and it comes back for another look. That means a schedule cannot arrive on your computer through a git pull or an installed package and quietly start running (DOR-1485)
A schedule that DorkOS cannot read now says so instead of going quiet. If the schedule settings have a typo, or the timing is written in a way DorkOS cannot make sense of, the schedule shows up waiting for you with the problem written out — naming the setting and what is wrong with it. The skill itself keeps working everywhere else; only the schedule half is held back (DOR-1485)
Agents you add while DorkOS is running have their schedules found straight away. Before, DorkOS only looked at each agent's folders when it started up, so a schedule that came with a newly added agent stayed invisible until the next restart (DOR-1485)
Approving a schedule no longer rewrites its file. Approving is a decision about the schedule, not a change to what it does, so DorkOS leaves the file exactly as you wrote it — including the comments, spacing and settings it does not recognise. If you do change what a schedule does, DorkOS writes that change into the schedule settings themselves rather than alongside them (DOR-1485)
Schedules that come from an installed package are left alone. You can switch one on or off, but DorkOS will not edit the package's own copy — that change would be shared by every agent using the package and would disappear at the next update (DOR-1485)
Saving a schedule's file no longer makes you approve it again. Many editors save by replacing the file rather than changing it, and installing a package update does the same; DorkOS now recognises that the schedule came back unchanged. Genuinely changing what a schedule does, or when it runs, still brings it back to you for a look (DOR-1485)
Removing the schedule settings from a skill now switches its schedule off, even if DorkOS was not watching at the moment you did it. It stays in your list, switched off, with its history intact (DOR-1485)
Schedules that came with an installed package are found. They arrive as a shortcut into the package's own folder, and DorkOS was quietly skipping every one of them, so a package could ship a schedule that never appeared anywhere (DOR-1485)
DorkOS now records your approval of a schedule directly, rather than working it out from whether the schedule is switched on. Switching a schedule off, or removing the agent it belongs to, no longer has any bearing on whether it counts as approved — so a schedule you never approved cannot end up running because something else switched it around. Schedules you had already approved stay approved when you upgrade (DOR-1485)
When a schedule is waiting because its file changed, DorkOS says so in its own voice instead of appearing to quote an agent that never said it (DOR-1485)
Editing a schedule that is already running keeps it running. Changing what it does, or when it runs, no longer sends your own schedule back to you for approval a few minutes later. If an agent makes the change instead of you, it still comes back for a look (DOR-1485)
The features list on dorkos.ai now includes seven things that shipped without ever getting written down: your Inbox, alerts that follow you to your phone, schedule approvals, reply limits, the activity feed, billing an agent to a different Claude account, and Shapes (DOR-1516)
The comparison pages ask six new questions, and they are the ones people actually run into. Does it use the plan you already pay for? Can an agent book itself a repeating job, and do you get a say? Can you stop your agents talking to each other all night? Can you read the code and skip making an account? Can you say yes from your phone? Is there one list of everything waiting on you? (DOR-1516)
DorkOS now keeps a searchable copy of what was said in your Claude Code chats — including the ones you ran from the plain claude command line, outside DorkOS. It reads the chat files Claude Code already writes and never changes them. Nothing in the app searches this yet; the search box itself comes next (DOR-681)
It only keeps what was said: your messages and the agent's replies, in plain words. Command output, file contents, and the agent's private notes are left out on purpose, so the copy stays small and a search does not fill up with machine noise (DOR-681)
A few kinds of chat are left out for the same reason. Conversations a helper agent had with itself are not yours, so they are skipped. So are the throwaway chats our own test runs produce (DOR-681)
The copy stays up to date without re-reading everything. DorkOS remembers how far into each chat file it got and picks up from there, and it notices a chat that was half-written when it looked — so a message that was still being saved is read whole the next time round, never cut in half (DOR-681)
Your agents remember what they learn. Every agent now keeps a short notes file of its own, beside its instructions and its boundaries. It reads those notes at the start of every conversation it joins, and writes down what is worth keeping. Tell an agent something in a private chat, and it still knows in a team channel next week (DOR-632)
Every note the agent saves records where it learned it, like "(noted in #product, 2026-08-24)". The agent does not choose that part, so a note always says where it came from, and a note that turns out to be wrong tells you which conversation taught it (DOR-632)
The notes file is plain markdown you can open in any editor, or from the agent's profile. Fix a line to correct it. Delete a line to forget it. It holds about 8,000 characters, which is small on purpose: the notes travel with every turn, so when the file fills up the agent is asked to tidy it rather than grow it (DOR-632)
Anything in the notes file can come up in any conversation the agent joins, including channels with other people in them, so never put a secret in it. The file explains this rule at the top, and it is the only thing that crosses between conversations. The conversations themselves never do (DOR-632)
Agents are now told the plain truth about how they run: each conversation is one session of the agent, sessions share the notes file but not the conversation, and an agent asked about work it cannot see should say so rather than guess. That last one is the difference between an agent that forgot and an agent that was never there (DOR-632)
You can now ask DorkOS where something was said, and get an answer back in one request: GET /api/search?q=… looks through your rooms and your Claude Code chats at once and returns the best matches, each with the sentence it was in and the words you searched for marked. The search box you will click is still on its way (DOR-684)
Results come back ranked together rather than sorted by where they came from, because "where did we talk about the scheduler" does not know whether you said it in a channel or to an agent (DOR-684)
Searching matches whole words, including their other forms: look for dogs and you will find "dog", "dogs" and "DOGGED". A piece of a word, like ogs, finds nothing (DOR-684)
Each result carries what it needs to be opened later — which chat or room it was in, where in it, who said it, and when (DOR-684)
The searchable copy of your Claude Code chats now covers every Claude Code account on your computer, not just the one DorkOS happens to be pointed at. It used to read a single account and say nothing about the rest — about half the chats on the computer where this was found, and less on a computer with more accounts. Nothing in the app searches this yet; the search box itself comes next (DOR-682)
Which accounts get read is the same list DorkOS already uses everywhere else: the one you picked, the one your terminal points at, ~/.claude, and any account you added in settings. Nothing is guessed — DorkOS does not go hunting for folders that merely look like accounts (DOR-682)
If one account's folder cannot be read, DorkOS names that folder in its own log and keeps what it already knows about the account rather than throwing it away. There is nothing to see in the app; the note is for whoever goes looking in the server log (DOR-682)
Search your messages. Press ⌘⇧F (Ctrl+Shift+F on Windows and Linux) and type what you remember somebody saying. DorkOS looks through your channels and direct messages, and your Claude Code, Codex and OpenCode conversations, shows you the sentence it found with your words picked out, and takes you to the conversation it was said in. (DOR-685)
The box tells you what it can and cannot see. Before you type anything it says which conversations it searches and which it does not, that tool output and file contents are never searched, and that it matches whole words — so ogs will not find dogs, but dog* will. Nothing about the edges of search is left for you to discover by getting no results. (DOR-685)
⌘K now offers "Search messages for …" as its last row, carrying whatever you already typed. ⌘K still finds things by their name — an agent, a channel, a conversation — and the new box finds them by what was said inside them. They stay two separate boxes on purpose. (DOR-685)
A conversation whose project folder has been deleted still turns up, and still opens: you can read what was said, and DorkOS tells you the folder is gone rather than failing. (DOR-685)
The searchable copy of your chats now covers your Codex conversations too — live ones and ones you archived. DorkOS reads the files Codex already writes, so chats you had in DorkOS and chats you had in the plain codex terminal are both in there. You can search these from the search box (⌘⇧F) (DOR-683)
Only what was actually said gets saved: your words and the agent's replies. The setup text Codex and DorkOS slip into a message before sending it — the project notes, the environment block, the widget instructions — is left out, so searching does not turn up things nobody said (DOR-683)
Codex records every message twice in its own files, once for the model and once for the on-screen log. DorkOS reads one of the two, so a chat you had once shows up once (DOR-683)
If Codex has never run on your computer, this quietly finds nothing and says nothing (DOR-683)
The searchable copy of your chats now covers your OpenCode conversations too. With this, every runtime DorkOS can run is in there — your rooms, Claude Code, Codex and OpenCode. You can search these from the search box (⌘⇧F) (DOR-688)
DorkOS reads them without ever opening OpenCode's own file. Each pass takes a copy, reads the copy, and deletes it. OpenCode keeps its sign-in details in the same file as its messages, so DorkOS reads only the three tables that hold conversations and cannot reach the rest — no account or password can end up in the search index, and DorkOS never starts OpenCode in the background to read them (DOR-688)
Anything you actually typed is kept as you typed it, including a key you happened to paste into a chat. That is your own conversation, and DorkOS treats it the way it treats every other word in it (DOR-688)
Conversations a helper agent had with itself are left out, and so is a conversation OpenCode has deleted. If you have never used OpenCode, nothing happens and nothing is reported (DOR-688)
A conversation you are in the middle of gets picked up properly. OpenCode writes an answer a piece at a time over as much as a minute, so DorkOS keeps re-reading anything touched in the last quarter of an hour until it settles — otherwise you could search for a sentence your agent said and never find it (DOR-688)
If DorkOS cannot read OpenCode's file at all, searches now say so instead of quietly returning less, and the other chat sources keep working rather than going quiet alongside it (DOR-688)
If OpenCode's file is briefly unreadable while DorkOS is copying it, DorkOS waits rather than deleting conversations that are still there (DOR-688)
Your agents can now look things up in any room they are in, not just the one they are answering in. Ask in one channel about something that was decided in another, and the agent finds it and tells you which channel it came from. It can also list the rooms and direct messages it belongs to, so it can say where it has been and read a conversation back (DOR-1532)
An agent only ever finds what it was there for. It sees the rooms it is a member of and nothing else, and in each one it starts from the day it joined — so adding an agent to a long-running channel does not hand it the years of conversation that happened before it arrived. A room it is not in returns exactly what a room that does not exist returns: nothing at all (DOR-1532)
Agents are told when to use this. The same short note that tells an agent it is one session of itself now adds the next step: if you are asked about something said in another room you belong to, go and look, and if you cannot find it, say so rather than guess (DOR-1532)
Your agents keep working even if the thing storing their memory stops working. Memory now lives behind a swap point, so it can come from somewhere other than the notes file DorkOS ships with. If whatever you choose starts failing, DorkOS goes straight back to the notes file, mentions it once in the log, and your conversations carry on as normal — a memory problem can never end a chat. Worth knowing: while DorkOS is falling back, an agent reads the notes file rather than the backend that stopped answering, so notes kept only in that backend are out of view until you fix it and restart (DOR-1533)
A new setting, memory.provider, says where your agents keep what they remember. It starts as builtin: one small notes file beside each agent, on your machine, which you can open in any editor. Only you can change it, and a change takes effect the next time DorkOS starts (DOR-1533)
The plugin build now packages SQLite alongside the plugin, picking the build that matches whichever Obsidian you run it on. Every one of them is checked against a recorded fingerprint each time it is used — not just the first time it is downloaded — so bytes that are not what they claim to be stop the build instead of shipping (DOR-1563)
The plugin now carries the rest of what searching your history needs: a strictly read-only path to the copy the DorkOS app keeps. Read-only is the guarantee, not a detail — it will not create a database, change one, or add to one, so it can never disagree with the DorkOS app about your own data. Where there is nothing to read, it stays out of the way rather than quietly finding nothing (DOR-1563)
Anything read that way respects exactly the same limits as the DorkOS app. If your DorkOS asks people to sign in, the plugin works out who owns it from the database rather than assuming it is you (DOR-1563)
The desktop app now shows a notification when an agent proposes a scheduled task, or asks to do something it cannot undo — like deleting a schedule. Both used to show nothing at all on the desktop: the only sign was a quiet count on the bell, so you had to be looking at the right window to notice. Click the notification to open the thing you need to decide. (DOR-1570)
When an agent asks to do something it cannot undo and nobody answers, DorkOS now reaches your phone after the same delay a proposed schedule uses — the "escalate to my phone after" setting under Notifications. Before this, that kind of request could sit for its full two hours with no signal outside the app. (DOR-1570)
You can now search what was said from inside Obsidian. ⌘⇧F opens the same box as the DorkOS app, over the same history, showing you the same things — and ⌘K offers the way in, the same as it does in a browser (DOR-1563)
It appears only where there is something to search. On a machine where DorkOS has never run, or in an Obsidian this build of the plugin has no database engine for, the box and the ⌘K row are simply not there — rather than being there and finding nothing (DOR-1563)
The box tells you the one way it differs there: in Obsidian it shows what the DorkOS app has already indexed, so anything said while only Obsidian was open turns up once you have opened the app. Your channels and direct messages are current either way (DOR-1563)
Scheduled tasks can now pick up where they left off. Flip on the new Sticky toggle when you create or edit a task, and every run resumes the same conversation instead of starting cold — so your agent can say things like "since I last ran, here's what changed." It keeps working across restarts, not just back-to-back runs. Leave it off (the default) and each run stays its own fresh, isolated session, exactly as before. Every run still shows up in the task's history, and opening one takes you to that conversation with everything from the runs before it. If a run is still going when the next one is due, that next run is skipped rather than talking over itself. (DOR-1571)
If you build or run a custom memory backend behind DorkOS's memory provider seam, DorkOS now tells you when it stops using yours — instead of quietly falling back to its own local notes and only saying so once in the server log. A banner in the app names the backend and says why, and GET /api/system/memory reports the same thing for anyone scripting against it. This only matters if you've registered a backend of your own; a stock DorkOS install always uses its built-in memory (DOR-1560)
When that fallback already has notes on it and DorkOS injects them into a turn, the affected agent is now told those notes come from a different local store, not its usual memory, so it does not assume anything missing was never saved. This does not cover every fallback yet — the more common case, an agent's very first turn on the fallback, stays silent for now (DOR-1560)
Click a search result from a channel or direct message and you land on that message, not just somewhere in the conversation. It scrolls to it and marks it for a moment, so you can see straight away which line answered you — and the address in your bar points at it too, so a refresh or a link you paste to somebody lands in the same place (DOR-687)
Search again without leaving, and the conversation moves to the new message. Picking a second result in the room you are already reading takes you there, the same as the first one did (DOR-687)
Pick a result that was said inside a thread and the thread opens with that reply on screen, rather than leaving you on the collapsed "3 replies" line (DOR-687)
If the message is not among the ones the conversation currently has open, DorkOS says so in one quiet line instead of dropping you at the bottom and letting you wonder. Everything said there is still there (DOR-687)
Results from your Claude Code, Codex and OpenCode chats still open the conversation rather than the exact line. The numbering search keeps for those chats counts only what was said, so it does not line up with everything the chat shows — and landing on the wrong line would be worse than landing in the right chat. That one is still to come (DOR-687)

Changed

Skill files now take one set of options, everywhere. The settings that used to work only at the top of a command file work at the top of any skill: a hint for its arguments, a model, an effort level, and running it in a forked helper. DorkOS also reads the rest of Claude Code's options now, including which tools to keep away from a skill, which files it applies to, and which shell runs its inline commands. A skill you wrote for Claude Code needs no changes to be read correctly here (DOR-1484)
Task run history is now trimmed every hour rather than only when DorkOS restarts, and the history is indexed for the way it is read. A task that runs every minute was adding about 43,000 rows a month to a server that stays up, and every one of them was scanned each time you opened the runs list (DOR-1482)
A package can never switch its own scheduled task on. Whatever the package asks for, the task waits for you to approve it before it runs for the first time, and a package cannot give itself permission to work unsupervised. (DOR-1487)
A package will not overwrite a skill of yours. When one tries to create a scheduled task where you already keep something — a skill, a draft, notes, anything at all — DorkOS keeps what is yours and tells you, rather than replacing it. (DOR-1487)
If you change when a packaged scheduled task runs, or what it is allowed to do, updating that package puts its own settings back — and now says so, naming the task, instead of letting your change disappear quietly. (DOR-1487)
Rooms, Connections and the Slack adapter are no longer labelled earlier than they are. Rooms in particular is the screen DorkOS opens on, so calling it experimental had stopped being true (DOR-1516)
Every comparison page got shorter and plainer. The verdicts are a few sentences instead of a paragraph, the questions and answers are trimmed to the ones people ask, and the pages stop explaining themselves with metaphors (DOR-1516)
Comparison pages used to open by telling you that searching the other way round lands on the same page, which is a fact about search engines rather than anything you wanted to know. They now open with a sentence about the two tools (DOR-1516)
Two ownership changes we had wrong: Cursor is owned by SpaceX, which bought Anysphere in August 2026, and Grok Bot is made by SpaceXAI. That also means the two share an owner, so Grok Bot coming with some Cursor plans is one company bundling its own product. Both pages now say so (DOR-1516)
The pages are clearer that these agents are not only for code. They write the code, and they also send the email, plan the week and book the call (DOR-1516)
We stopped calling DorkOS "mission control" or a "cockpit". It is simpler than that: one place for every agent you run. The website, the docs, the app and the install instructions all say it the same way now (DOR-1517)
The feature page for running Claude Code, Codex and OpenCode together moved from /features/multi-runtime-cockpit to /features/every-agent-one-place. The old address still works and sends you to the new one, so any link you saved or shared is safe (DOR-1517)
The scheduler now calls its work scheduled tasks, and Schedules where a label has no room. The word "task" was doing two jobs: the thing you put on a timer, and the to-do list an agent keeps while it works on your message. Now only one of them is called a task, and the tab, the page, the dialogs, the command palette and the activity feed all say the same word (DOR-1490)
The guide is rewritten around what actually changed underneath: any skill becomes a scheduled task when you add a few lines of timing to it, and DorkOS finds it wherever your skills live. It covers where DorkOS looks, why nothing runs until you approve it, what happens to schedules you already had, and the one gotcha worth knowing before you flag a skill as "do not pick this up on your own" (DOR-1490)
The /flow guides now show the new format and the one step that turns it on: approve flow-drain on the Schedules page. Approving is what arms and enables it together — no file edit required first (DOR-1490)
Your scheduled tasks live with your skills now. The first time you start this version, DorkOS moves every one of them out of its old folder and into ~/.dork/skills/ (or your project's .agents/skills/), and rewrites the settings at the top of each file into a schedule: block. Nothing to do, nothing to click — and the ones you had already approved stay approved and keep running (DOR-1486)
New scheduled tasks land in the same place, in the same shape, whether you make one in the app, an agent proposes one, or a Shape sets one up for you. There is one kind of file now: a skill, which may or may not have a schedule on it (DOR-1486)
A schedule that a Shape sets up now waits for you before it runs, the same as one DorkOS finds in a file. Applying a Shape means you want the arrangement; saying yes to a job that runs on its own is a separate answer (DOR-1486)
Text somebody pastes into a room is neutralised a little more thoroughly before an agent reads it. DorkOS already wraps other people's messages in a marked-off block so an agent treats them as words rather than instructions, and a handful of DorkOS's own internal markers could previously survive inside that block. They no longer can. Nothing you type looks different and the same words reach the agent — they just cannot pretend to be part of DorkOS's own instructions any more (DOR-632)
A note that quotes somebody else stays a quote. Every note records the conversation it was written in, and that stamp is written by DorkOS rather than by the agent — so a note saved in a busy channel cannot come back later claiming to be something you asked for. Only what you say in a direct chat sets your agent's standing preferences (DOR-632)
Anything said in a room can be found straight away, instead of after the next few-minute catch-up. Claude Code chats still take up to five minutes to show up, because DorkOS has to notice the file changed rather than being told (DOR-684)
The Slack connection now runs on the latest Slack toolkit (Bolt 5 and Web API 8). Setting up and using Slack is unchanged (DOR-1528)
DorkOS now runs one version of the library it uses to check that data has the right shape, instead of two. Three parts of the app — marketplace packages, skills, and the harness that projects them into your agents — were a major version behind, so every place those parts met the rest of the app needed a hand-written translation kept in step by hand. One less way for a package or a skill to be read differently depending on which door it came in through. (DOR-1527)
The app loads a little less code. The marketplace screens and the rest of the app each pulled in their own copy of that library, so both were shipped to your browser; now there is one. (DOR-1527)
A few messages about a broken schedule: block in a skill file are worded differently, because the wording comes from that library. A cron that should be text but is a number now reads "Invalid input: expected string, received number" where it used to say "Expected string, received number". Same problem, same field named — just the tail of the sentence. (DOR-1527)
"Preview what your agent will see", on the profile, now shows the agent's saved notes as well — in the same place, and inside the same wrapper, a real turn puts them in. The preview is the whole prompt again rather than a tidied version of it (DOR-632)
The terminal built into DorkOS moved up to a new major version of the library that draws it. Scrolling back through what a command printed now uses the same scrollbar Visual Studio Code uses, and the terminal itself loads faster — the library shrank by about a third. Everything you do with it is unchanged: open a shell, type, scroll, keep several tabs side by side (DOR-1529)
We updated two of the libraries the app is built on to their latest major versions: the calendar component and the pinch-to-zoom, wheel-zoom, and drag-to-pan controls on canvas images. Nothing changes for you — both still look and work the same (DOR-1531)
The A2A gateway now speaks version 1.0 of the Agent-to-Agent protocol, and still accepts the version 0.3 calls it accepted before. Outside agents written against either version can reach your agents, and each request is answered in the version it was asked in. Agent Cards say so directly: they list your endpoint under both versions. Your stored A2A tasks carry over as they are — there is nothing to convert. (DOR-1530)
Agent Cards are laid out the way version 1.0 describes: the single url and preferredTransport fields became a supportedInterfaces list, and security became securityRequirements. If you read cards from DorkOS with your own code rather than an A2A client library, this is the one change to look at. (DOR-1530)
A version 0.3 caller that sends a message without saying blocking: true now gets the task back right away instead of waiting for the answer. That is what version 0.3 always said should happen, and DorkOS now follows it. If a call that used to wait no longer does, add "configuration": { "blocking": true } and it waits again. (DOR-1530)
Slack works through a corporate proxy. Set HTTP_PROXY or HTTPS_PROXY the way you always have, and DorkOS picks it up (DOR-1542)
Listing tasks over A2A stays fast as tasks pile up. DorkOS used to read every task it had ever stored to hand back a single page of fifty; it now reads only the page you asked for. (DOR-1548)
We updated the library behind the app's menus, dialogs, dropdowns, switches, tabs and slide-up panels. It had been held back because we thought the update would make the bottom sheet snap shut instead of sliding away — it doesn't. Nothing changes for you (DOR-1539)
The comparison pages at dorkos.ai/compare stopped hedging about DorkOS. They used to describe DeepSeek Harness as the closest thing to what DorkOS "is trying to be", which reads like a product that has not decided what it is yet. DorkOS is something. The pages now say so, and every other soft phrase about our own product went with it (DOR-1557)
Every verdict, answer and explanation on those pages got shorter again. Nothing was dropped: the facts, the credit we give other tools, and the places we say they beat us are all still there, in fewer words (DOR-1557)
"Which one is for you" now opens with the reasons to pick DorkOS, instead of reaching them after a panel about the other tool. It reads that way on a phone and on a desktop, and the DorkOS ticks are green so the two lists are easy to tell apart at a glance (DOR-1557)
An agent that proposes a schedule, or asks to delete one, is now told to say so in its reply instead of quietly stopping. It used to report the task as created and end the turn, leaving you to discover the approval on your own. In a DorkOS session it can also offer to open the Schedules panel for you. (DOR-1570)

Removed

The "Timezone" setting under Tasks is gone. Every schedule already carries its own timezone, so this one never had any effect — changing it did nothing at all. Set the timezone on the schedule itself, as you always have (DOR-1482)

Fixed

Clearing a scheduled task's time limit, display name, timezone, or cron no longer breaks the task's file. DorkOS used to write the cleared field as the word null, which it could not read back — after that the task stopped syncing, and every later edit to it quietly failed to save. (DOR-1481)
Editing a task that runs only on demand now works. Saving one from the task form cleared its cron, which the database refused, so the edit failed — after the file on disk had already been rewritten, letting the half-finished edit apply itself seconds later. (DOR-1481)
When DorkOS cannot save a task's file — the disk is full, or the file is read-only — editing the task now fails with a message naming the file it could not write. It used to report success, then put the old values back a few minutes later with nothing to explain why. (DOR-1481)
A task whose file DorkOS cannot read or make sense of now says so when you edit it, and names the file to open. Editing one used to quietly succeed while the file stayed broken, so a damaged task had no visible symptom at all. (DOR-1481)
A time limit DorkOS cannot read, like 10 minutes, is now refused when you edit a task, exactly as it already was when you create one — through the task form, the API, and the tasks_update tool an agent uses. It used to be accepted and then removed the task's time limit altogether. Write it as 10m. (DOR-1481)
Canceling a task from another AI tool now actually stops the agent. Before, DorkOS replied "canceled" and the agent kept working — and kept costing you money — until it finished on its own. The cancel is now passed to whoever is running the turn, and you are only told it stopped when something confirms it did. If nothing can be stopped, you get an error saying so instead of a comfortable lie (DOR-791).
When an outside tool waits two minutes for an answer and gives up, DorkOS now asks the agent to stop too, and writes to the server log whether that worked (DOR-791).
The comparison tables now work on a phone. Each point becomes its own block, with both answers stacked underneath and labelled, so every word fits on screen and there is nothing to scroll sideways. Before, most of the second column sat off the edge of the screen with nothing to hint at it. On a tablet or a computer it stays a table, with the row label pinned as you scroll across and the edge fading to show there is more to see (DOR-1465)
Small grey text on the comparison pages is darker, so table headings, links and labels are easier to read and meet accessibility contrast standards (DOR-1465)
Links like "More on this" and "Back to the table" now land where they should. They used to jump to a spot hidden behind the top bar (DOR-1465)
The Cursor comparison now says that Cursor has a phone app, a web dashboard and a Slack integration, which it gained since the page was written. You can also reach the comparison pages from the site footer (DOR-1465)
Long web addresses in the "how we checked" list now wrap onto the next line. On a narrow phone one of them used to stretch the whole page sideways (DOR-1465)
The Codex page no longer says its source code is simply open. Only the command-line tool is: the cloud service, the apps and the models are not, and the page says so (DOR-1465)
A skill that lists its pre-approved tools the way Claude Code allows, as a YAML list instead of one line, no longer goes missing. Before, that one detail stopped the whole skill from loading (DOR-1484)
One option DorkOS does not recognize can no longer hide a skill. A line like shell: zsh is skipped over now, and the skill keeps working everywhere else (DOR-1484)
Starting a second copy of DorkOS no longer marks the tasks another copy is running as failed. Booting the app while a dev server or the desktop app was mid-task used to end those runs in the record, throw away what they actually did, and send you a "task failed" notification for work that was going perfectly fine. Now only the copy in charge of the schedule ends a run, and only when it can show nobody is still working on it (DOR-1482)
The limit on how many tasks run at once now counts every task, however it was started. With the message bus on, that limit counted nothing, so a slow task on a short schedule could pile up as many runs at once as the schedule allowed — and the "running now" count read zero the whole time (DOR-1482)
An agent changing a task's schedule now changes when it actually runs. Editing a schedule through an agent used to update what the screen showed while the old schedule kept firing, and deleting one left it running against a task that no longer existed — in both cases until you restarted DorkOS (DOR-1493)
A task that came round while DorkOS was starting up can no longer lose its turn without a trace: the record of a run and the note that its turn was taken are now written together, so a crash mid-way leaves the turn free for next time (DOR-1482)
A comparison page for a shut-down product no longer invites you to "see it for yourself", which led to a stub page or a read-only repository. Those pages now offer to show you what is left of it instead (DOR-1468)
The banner on a shut-down product's page used to promise that the details came from the company's own announcement, linked at the bottom. That is not always true: a company's website tends to go down with the company. The banner now says what the page covers, and the sources list says where we actually looked (DOR-1468)
The light gray text on dorkos.ai is darker now, so it is easier to read. It is the color used for the small print all over the site: breadcrumbs, table column headers, card labels, captions, and the source lists under the comparison tables. Against the site's cream background it was too faint to meet the accessibility standard for readable text, and most of it is only nine to twelve pixels tall, which is exactly the text you can least afford to squint at (DOR-1503)
The credit lines on the story page were the opposite problem. That page is dark, and the same gray was being used on it, which made it fainter still. Those lines now use the warm cream the footer already uses on dark backgrounds, so they are comfortably readable too (DOR-1503)
The floating menu no longer sits on top of what you are reading. As you scroll down a long page it steps out of the way, and it comes back the moment you scroll up, reach the top, or arrive at the end. Before this, it could cover a link and swallow the click (DOR-1504)
The menu fits on a phone screen again now that it holds six words. On the narrowest screens it drops "home", which the logo at the top already does (DOR-1504)
If you are moving through the menu with the keyboard, it now waits for you. It used to slide away mid-tab and drop you back at the start of the page (DOR-1504)
Installing a package with a broken schedule now fails immediately, naming the package's schedule and what is wrong with it. It used to install fine and then turn up later as a task that could never run, with nothing to explain why. (DOR-1487)
We were quietly claiming that scheduled work happens "while you are asleep or away". DorkOS runs on your own computer, so it needs that computer awake. The pages now say a job starts at a set time without you pressing anything, which is the true version (DOR-1516)
A plugin you install into a project can now offer you its scheduled tasks, whichever coding agents that project uses. Before this, a plugin that shipped a scheduled task was only set up for Claude Code on a normal project, and DorkOS does not look for schedules there — so the job sat on your machine and was never offered to you. Now a project plugin's scheduled tasks are put where DorkOS looks, and it asks whether you want each one to run. Plugins installed for your whole machine, rather than into one project, still cannot offer schedules this way (DOR-1518)
dorkos harness sync now explains the set-up steps that need explaining. A line used to say only what was linked and where, which reads as arbitrary when the folder belongs to a coding agent you do not use. Each such line now says why it is there (DOR-1518)
If two things wanted the same name — a task called digest and a skill called digest — the skill keeps its name and the task moves in beside it as digest-migrated, and shows up waiting for you so you can see what happened. Nothing is overwritten (DOR-1486)
A task file DorkOS cannot read is left exactly where it is, and appears on your Schedules page with the file's path and what is wrong with it, instead of being quietly left behind in a folder nothing looks at any more (DOR-1486)
A Shape can no longer write its schedule over a skill you wrote yourself that happens to have the same name. Your file stays exactly as it is, and applying the Shape tells you which schedule it skipped and why, instead of reporting one it never made (DOR-1486)
Your task templates keep their timing when they move. Before, a template that had moved offered no schedule at all when you picked it (DOR-1486)
An agent you add while DorkOS is running brings its scheduled tasks with it straight away, instead of waiting for the next restart (DOR-1486)
If one place DorkOS reads from cannot be read, search still answers with everything else and tells you one of its sources is behind — rather than failing the whole request or quietly returning a short list (DOR-684)
Sending a message can never fail because the search copy could not be updated. The room keeps your message either way, and the next catch-up adds it to search (DOR-684)
Searching one room is fast again. Looking inside a single room was taking seconds where searching everything took milliseconds — the database was reading the room the long way round. Agents reading their own room history were on that same slow path (DOR-684)
A very short search is turned down properly now. Typing a single letter with a comma after it looked long enough to run, and it was the slowest kind of search there is (DOR-684)
Posting into a room the search copy has never seen no longer waits while the whole room is copied. That catch-up happens in the background instead (DOR-684)
When your Slack token stops working — you removed the app, the token was revoked, or it never had the right permissions — the Slack connection now stops and tells you which problem it hit. It used to miss that the failure was permanent and keep retrying forever against a token that was never going to work again, so the connection sat there looking busy while every message quietly went nowhere. It also now shuts down cleanly, instead of leaving background timers running against the dead connection (DOR-1528)
Asking the A2A gateway to wait for an answer now really waits. It used to reply the moment it handed your message to the agent, so a caller that asked for the finished result could get a task still marked working and never see the answer arrive. (DOR-1530)
Agent Cards now go out in the format the protocol specifies. A few fields were being sent in DorkOS's own internal shape instead — the bearer-token security scheme in particular — which a strict A2A client could refuse to read. (DOR-1530)
OpenCode sessions you started in a subfolder now show up under the project they belong to. If you ran opencode in something like my-app/packages/api, that conversation was missing from my-app — and from every other project too, so there was nowhere to find it. It now appears everywhere a project's sessions are listed: the sidebar switcher, the agent's Sessions page, the command palette, the embedded sidebar, and the Recent list. Each session still shows the folder it is actually running in. Claude Code sessions in subfolders have the same blind spot in their own listing; that fix is tracked separately. (DOR-674)
An OpenCode agent that was working in a subfolder no longer looks idle. Its last-active time and its daily run counts skipped those sessions. (DOR-674)
Canceling a task from another app no longer loses the agent's reply. If the agent finished answering while the cancel was still on its way, DorkOS threw the answer away, told you the task could not be canceled, and left it stuck part-way — with no way to ask for the answer again. It now keeps the reply and finishes the task. (DOR-1547)
Asking one agent for its tasks now gets you that agent's tasks. A request to /a2a/agents/{agent} listed every agent's tasks instead, complete with their message history — and looking one up by its id from that endpoint worked too, whoever it belonged to. Both now answer for the agent in the address, and anything else reads as not found. Ask the fleet endpoint /a2a when you want the whole list. (DOR-1546)
A handful of small timing bugs on the website: the account-activation page no longer flashes an empty form for a split second while it checks your code, and pages that adapt to phone screens now get it right on the very first frame instead of correcting themselves after (DOR-1541)
The DorkOS plugin for Obsidian builds a bundle that can actually start. Two things in it were broken before the plugin got as far as loading: a patch the build applies missed some of the code it was meant to cover once the bundle was minified, and the database library worked out a file path the moment it was loaded rather than when it was needed. Both are fixed, and the build now stops with a message naming what it missed instead of quietly producing a plugin that throws on startup (DOR-1563)
Scheduled tasks no longer bury you in "could not be delivered" notifications. Every scheduled run was talking to itself: each thing the agent said got sent back to DorkOS as if it were a brand new job, failed to make sense, and turned into a failure notice. One run produced 279 of them. Runs now send that stream nowhere, because nothing was ever reading it. (DOR-1567)
A scheduled task is now told it is a scheduled task. When the message bus was on — which it is by default — the agent started with none of the usual briefing: what job this is, what schedule woke it, and that nobody is around to answer questions. So it would stop and ask. Both ways of starting a run now hand over the same briefing. (DOR-1567)
A scheduled run that stops to ask permission now gives up after ten minutes instead of waiting four hours. It already worked that way on one of the two paths a run can take; now it works on both, so a single unanswered prompt can no longer hold a run open for the rest of the day. (DOR-1567)
A scheduled run that fails is now clickable in the run history, so you can open the transcript and read what went wrong. Finished and cancelled runs already linked to theirs; the failed ones — the runs you actually want to read — did not. (DOR-1567)
A task an agent schedules for you is now a real task. It used to make a task with no file behind it and no owner, so nothing kept it in step with your project and its runs happened in the wrong folder. The agent is now asked where the task belongs — under itself, or in your DorkOS folder — and the task is written there like any other. (DOR-1568)
An agent that asks to schedule a task for an agent DorkOS has never heard of is now told so, instead of quietly making a task nobody owns. (DOR-1568)
A time limit an agent sets when it schedules a task is now kept. The tool accepted the setting and then threw it away, so the task ran with no limit at all. (DOR-1568)
Deleting a task through an agent now deletes it. Only the entry was removed, so the task came back on its own a few minutes later, after the agent had already said it was gone. (DOR-1568)
Editing a task now refuses a field it cannot change, and says which one. Anything DorkOS did not recognise was thrown away and the edit reported as a success — which is how an agent came to believe it had filed a task under itself when nothing had happened. Where a task lives is decided when it is created; to move one, delete it and create it again. (DOR-1568)
When you tell your agent a standing rule in a one-to-one chat — "we deploy on Tuesdays, never Fridays" — it now writes that down before the turn ends, so a later conversation in a channel knows it. Some models used to answer "got it" and save nothing, and the next conversation had no idea. (DOR-1564)
Search keeps filling even when one of the places it reads breaks. If DorkOS could no longer read a folder or a program's history — the files moved, or it lost permission to open them — everything from that one place quietly stopped being added to search, and nothing told you. Now your search results say that part of your history could not be read, nothing already found is thrown away, and every other place carries on being added. (DOR-709)
The app stays responsive while search catches up. Adding to the index used to hold up everything else until it finished, which is most noticeable the first time you run DorkOS, when there is a whole history to get through. It now works in small pieces and gives the app a turn between each one, so it fills in the background instead of in your way. (DOR-702)

Security

Only a person can run a scheduled task on demand. An agent could ask DorkOS to run a task right now — including one that was parked, waiting for you to approve it — which walked straight around the approval. You can still run a proposed task once from its approval card to see what it does. (DOR-1481)
Searching your own machine reaches every room on it, including rooms your agents opened between themselves and never invited you to. That is deliberate — it is your install, and search is how you find something you half-remember — but it is worth knowing, because it is more than the room list shows you (DOR-684)
Your own chats with agents stay yours. An agent searching gets only the rooms it is actually in, and only from the point it joined — never what was said in a room before it arrived, and never anything from your Claude Code sessions (DOR-684)
Asking about something you are not allowed to see gets exactly the same answer as asking about something nobody ever said, so a search can never be used to find out that a private room exists (DOR-684)
We updated the libraries DorkOS is built on and closed almost every open security warning: 109 of them before, 6 after. Nothing you do changes — this is the plumbing underneath. Among the ones now fixed: a flaw that let a web page read files the dev server was told to keep private, a flaw in the desktop installer's archive handling, and a bug that could leak the credentials used to publish a release (DOR-1526)
The six that remain are in Electron, which the desktop app is built on, and in one archive-unpacking helper that has no fix published yet. Both are held for a separate update so they can be tested on their own (DOR-1526)
With Require login turned on, only a person signed in to DorkOS can approve a scheduled task, turn off its safety prompts, or start one running. Before, anything holding one of your personal API keys counted as you for these — so a program on your machine could set up a task that runs on its own, at full power, without you ever seeing it. Approving a task now needs a real sign-in, the same bar DorkOS already uses for its other sensitive actions. Setting up tasks from the dorkos command line still works; a task it creates now waits for you to approve it in the app. (DOR-1569)

For contributors

Two seams landed under this release. Message search is a derived, rebuildable index rather than a second transcript store — deleting it is a supported recovery (ADR 260728-214214) — and agent memory arrived behind MemoryProvider, DorkOS's fifth swappable port, with its own conformance suite. Scheduling also stopped being a directory and became a frontmatter property (ADR 260823-200724), with file-discovered schedules that never auto-arm (ADR 260823-200726).

Install / Update

npm install -g dorkos@0.65.0