Account › Notifications › Settings now lists every phone and computer you turned push on for, with Remove beside each. Send a test shows whenever you have one, even in a browser where push is off, and sends to all of them.
Changelog
What's new in Reminix.
Every change you'd notice in the app, the API, the SDKs and the CLI, newest first.
November 2026
When you open the app from your phone’s Home Screen, it offers to turn on push notifications. Tap Turn on and a test notification follows. Not now hides the offer for 30 days.
When you create your first workspace and choose Other for How did you hear about us?, you can now tell us where. The field is optional and takes up to 100 characters.
Long names and email addresses fit on a phone: your email on Account, and “(you)” beside a long name on Members, no longer push the page sideways or out of sight.
The dashboard is easier to use on a phone. The notifications menu has a settings button, which opens your notification settings. On an approval request, Approve and Deny stay at the bottom of the screen, where your thumb is, and every input is listed with its name. The installed app’s icon shows how many notifications you haven’t read. The status bar matches light and dark mode from the moment the app opens, and the app opens on its own launch screen. The offline screen looks like the rest of the app. On Android, press and hold the icon for shortcuts. Small buttons and links are easier to tap.
The dashboard can send push notifications to your phone or computer. Turn them on in Account, Notifications, Settings. There you also choose how you hear about each kind of notification: in the app, by email or by push. On an iPhone, add the dashboard to your Home Screen first.
A run waiting for your approval now reaches you by email and push as well as in the app. When a run fails, the person who started it gets a notification in the app and an email, with a link to the run. Choose how you hear about each in Account › Notifications › Settings.
Runs, scripts and approvals read better on a phone. Long inputs, output and logs wrap instead of running off the screen. A long log shows its last 20 lines, with a button to see the rest. A failed run shows its error first, with the real error at the top and the full message as the script wrote it. A run waiting for approval names its script, and lists every input on its own line. On a script’s page, the Run button now fits on a phone’s first screen.
Every ID now starts with a short prefix that says what it is: ws_ for a
workspace, usr_ for a user, mem_ for a member, key_ for an API key.
IDs made before this change keep their old form. Treat an ID as an
opaque string: compare it, store it, never parse it.
Your picture is now at the top right of every page. Tap it for your account, notifications, the theme and signing out.
On a phone, the dashboard looks the same in your browser as it does installed. The tab bar at the bottom holds your main pages. When there are more pages than fit, More lists the rest.
The privacy policy now says that when you sign up, we record the link or site you came from, and your answer if you tell us. It is kept with your account and deleted with it.
When you create an API key, it now always gets the access you chose. Before, on a slow first load, the Create API key dialog could show Read only and then switch to the suggested access. You can see each key’s access on Developers and change it with Edit access.
The installed app feels more like an app. On a phone, pull down at the top of a page to refresh it. The page no longer bounces past its ends, and the bar at the top of your phone matches the app’s light or dark look. On a computer, the app’s own window has Back and Reload buttons.
When you lose your connection, the app shows that you’re offline instead of the browser’s error page. It reloads by itself when you’re back online. When we release a new version, you move to it the next time you go to another page, without losing anything you were typing.
Every menu of more actions now opens from the same three-dots button. On a phone, settings pages no longer show their name twice.
You can install the dashboard as an app on your phone or computer: choose Install app in your account menu. It opens in its own window with its own icon. On a phone, your main pages are in a tab bar at the bottom of the screen. Buttons are also easier to tap on a touch screen.
Scripts, runs and files are easier to read on a phone. Each one is a single row that says what it is, how it went and when, and a tap opens it. A script’s versions keep their command on one line. Environments, secrets and access put a row’s actions in one menu.
Reminix has a status page at status.reminix.com. It shows whether the website, the app, the API, the docs, the MCP server and runs are up. You’ll find it in the site’s footer, on the Support page and in the app’s Help menu.
The dashboard is easier to use on a phone. Settings opens as a list, like your phone’s own settings. Lists show one tidy row per item, with their filters behind a single Filter button. Installed on a phone, the bottom bar has a More tab for everything else.
The workspace’s audit log (GET /v1/workspace/audit-events) records
billing.cancellation_undone when a plan set to cancel is kept after all.
The workspace’s audit log (GET /v1/workspace/audit-events) records more
events. It now includes the workspace’s creation and deletion, a declined
invitation, and plan changes: workspace.created, workspace.deleted,
workspace.invitation_rejected and billing.subscribed,
billing.plan_changed, billing.cancellation_scheduled and
billing.subscription_ended.
GET /v1/workspace/usage now says where each count stands. Each count
gains label, state and stopsAt, and unit when the plan names
one. The response gains a state for the whole workspace.
client.workspace.usage.get() and the Python client return them. The
CLI’s workspace usage prints each count as a sentence that says where
it stands. Use --json for the response as it is.
Publishing (reminix publish, POST /v1/scripts/{slug}/versions) now
refuses a command that puts an input inside code given to an interpreter
on the command line, such as sh -c 'echo {name}' or
python -c 'print({name})', because the interpreter would run the value
as code. The error shows the safe form, with the input as its own
argument: sh -c 'echo "$1"' _ {name}. Versions published before keep
running.
Triggers have a type. POST /v1/scripts/{slug}/triggers takes
type: "event" or type: "webhook". An event trigger’s eventType is
now event, and a trigger’s filter is null for a webhook trigger. A
webhook trigger starts a run when its URL is called with its secret; it
can take inputs from the call (inputMode), lock saved inputs
(lockedInputs) and check a Stripe or GitHub signature (signature,
signingSecret). Creating one returns its url and secret, once.
POST /v1/scripts/{slug}/triggers/{triggerId}/rotate-secret gives a new
one, and GET /v1/scripts/{slug}/triggers/{triggerId}/calls lists its
recent calls. A run’s via can now be webhook, and a run has
automationName, the name of the schedule or trigger that started it. An AI agent can’t
create a webhook trigger or rotate its secret. It asks with the approval
actions trigger.webhook.create and trigger.webhook.rotateSecret, and
a workspace owner approves.
An approval request for a run now has a plain summary, such as “Run
refund-customer (version 2) in production”, without the run’s inputs.
The inputs are in the request’s input (GET /v1/approvals/{id}). Its
reason is empty, because Reminix writes none of its own for a run;
the summary says what will happen.
Members and pending invitations now carry seat: the seat type a person
holds or will hold (GET /v1/workspace/members,
GET /v1/workspace/invitations). It is null for a guest, or where the
product has no seat types.
In Reminix a seat is "publishers" or "runners". An invitation can
choose either.
Only publishers create scripts, upload versions and publish them. A
runner gets 403 forbidden for those, and so does anyone uploading a
version of a script they can’t publish.
GET /v1/workspace/usage no longer has the authors count. Seats
replace it.
A workspace keeps up to 1 GB of files on Free, 10 GB on Pro and 100 GB
on Business. An upload past that gets 402 plan_limit_reached.
Pass an API key as apiKey in TypeScript (createClient({ apiKey }))
or as api_key in Python. Keep token for a personal access token.
Code that passes an API key as token still works.
Without either, the client reads your API key’s environment variable, as before. If that isn’t set, it now reads the personal access token variable the CLI uses.
The usage count authors is now described as “People who published or
uploaded this month”. Its id and numbers haven’t changed.
Listing files filters by file name with name, which replaces q. Every
filter is now named after the field it narrows.
Lists can start from a date. GET /v1/workspace/audit-events and
GET /v1/workspace/webhook-endpoints/{endpointId}/deliveries take
before, an ISO time, and return the items older than it, newest first.
Audit events take two filters. action keeps one kind of event.
actor keeps what one person, key or token did: pass user: and an
item’s actor.id, or credential: and its credential.id. Each audit
event now carries those ids.
Webhook deliveries take status: pending, delivered or failed.
Error messages and CLI output read as whole sentences: what went wrong,
then what to do. For example, an unknown environment now says
Unknown environment "staging". This product's environments are test, live.
Error codes are unchanged, so code that checks error.code keeps
working. Code that matches the exact text of a message may need
updating.
Error messages are easier to read. Each one states the problem in one sentence, then what to do in the next:
SHOP_KEY has no value in staging. Add it in Settings → Scripts.
If your code matches the text of an error, match its code instead.
The codes haven’t changed.
Environments and secrets now live under Settings → Scripts in the app. A run error that sends you to the app to fix a secret or an environment now names that tab.
Listing runs takes status, which keeps only runs in one state, such as
failed. Listing runs and listing files both take before, which starts
the list from a moment instead of from now. For example,
before=2026-11-01T00:00:00Z lists what came before November.
API keys and webhooks now live together under Settings → Developers in the app, and the descriptions of the API key and webhook endpoint operations point there.
An approval request (POST /v1/workspace/approval-requests) now runs in
the environment it was filed in once a person approves it, such as live
when you asked from live. Before, it ran in the default environment
unless its input named one. Requests filed before this change still
run in the default.
The descriptions of every method and command are rewritten to be easier to read: one rule per sentence, with nothing about how calls behave changed. They now also say that only workspace owners can manage webhook endpoints with a personal access token. Every response in the API reference now comes with an example of what it returns.
Method and command descriptions are clearer, and say who can call each
one. A workspace API key’s access to updating, archiving, restoring and
test-running scripts is now stated. The CLI’s reminix publish,
reminix upload and reminix run shortcuts describe themselves the
same way as the full commands.
The API reference’s “Too many requests” answer now gives the limit: 100
requests a minute for each credential, whether an API key, a personal
access token or an agent’s sign-in. Wait the number of seconds in the
Retry-After header before trying again.
reminix files download <file-id> --json prints the file’s details and
where it was saved, like every other command’s --json.
files.upload refuses a file over the plan’s size with 402 plan_limit_reached, naming the plan’s limit, on every plan. On Pro and
Business a file just over 100 MB used to get a generic 413 instead.
Clearer, corrected descriptions for Reminix’s operations in the API reference, the SDKs’ type hints, the command line’s help and the MCP tools:
runs.create(andscriptVersions.testRun) documents its 429: 100 requests a minute per key or token, or the plan’s runs at once all going. Its 402 now also names used-up long-run minutes and a file input larger than the plan takes, and its 400 an archived script. A run takes at most its version’stimeoutSeconds, not always 30.runs.cancelsays a cancelled run sends arun.cancelledevent, and that a workspace API key may cancel too.files.uploaddocuments its 413: uploads over 1,000 MB are refused. An upload can be given to one run.files.get: an upload not yet used is also readable by owners, admins and workspace API keys.scripts.update: its 402 is about every-run approval (Business), and it changes tags too.scriptSettings.update: its 402 is about second-person publishing (Business).schedules.updateandtriggers.update:enabledno longer claims a default; leaving it out keeps it as it is.- Name rules are given where they are checked: a script’s
slug, its tags, an environment’sname, a secret’sname, and a secret’svalue(at most 16,384 bytes).
Path parameters such as endpointId and deliveryId now come with a
description (“The endpoint’s ID.”) in the SDKs’ type hints, the
command line’s help and the API reference.
A run.cancelled webhook event, sent when a run is cancelled: by
someone (runs.cancel), or because its approval was denied, expired or
couldn’t start. Its data is the same as run.failed’s, with error
saying why. Triggers can start a script on it.
GET /v1/workspace/usage returns its list as counts instead of meters.
Update anything that reads meters from client.workspace.usage.get(), the
Python client or the CLI’s output.
October 2026
POST /v1/scripts/{slug}/runs no longer fails a run because no machine
was free at once: the run waits up to 2 minutes for one, and its
timeoutSeconds counts from when its code starts. A short run still
answers 200 when it ends within 60 seconds; one still going then
answers 202 with status running, like a long run, and you follow it
with GET /v1/runs/{id}.
login and logout now point to Account → Personal access tokens,
the page’s new name in the app (it was “API tokens”).
You can now change a webhook endpoint’s URL, description or event types
without deleting it: client.workspace.webhookEndpoints.update()
(PATCH /v1/workspace/webhook-endpoints/{endpointId}). The endpoint
keeps its signing secret, so your verification code keeps working.
An AI agent connected through the MCP server can no longer change who
may run a script or which of its runs need approval:
PATCH /v1/scripts/{slug} (scripts.update) answers 403 forbidden
when an agent’s token sends access, teamIds or approvalPolicy.
People’s own tokens and API keys change them as before. And with
approvalPolicy: "always", an agent’s run now always waits for
approval, even when an owner or admin connected the agent.
One name per idea, across the API, the SDKs, the CLI and MCP (breaking, before 1.0):
- Upload a version is
scriptVersions.upload(script_versions.uploadin Python), and takessource(wasarchive),install(wasbuild),timeoutSeconds(wastimeout) andenvVars(wasenv). A version answers withversion(wasnumber),install,installLog,buildBytes,buildSha256,envVarsandvia(wascreatedVia); version paths are/versions/{version}. - Test-run a version is
scriptVersions.testRun(test_run). - A run has
via(wasinterface; an agent’s runs areagent, wasmcp) andstartedBy: { userId, name, credential: { type, name } }. Its log isruns.logatGET /v1/runs/{runId}/log(wasruns.logs,/logs). The 202 schema isRunAwaitingApproval(wasHeldRun). - A file has
origin(inputorsaved, wasdirectionin/out),input(wasfield) andmediaType(wastype); list files with?origin=.files.uploadandfiles.download(atGET /v1/files/{fileId}/download) replacefiles.createandfiles.content. The SDKs’FileUploadtakesmediaType(media_typein Python). A script saves files to/saved($REMINIX_SAVED, was/outputs), and reads its inputs file at$REMINIX_INPUTS_FILE(was$REMINIX_INPUTS). - Secrets:
allowEnvVar(wasallowEnv; the CLI’s--allow-env-var), a secret use’sformat(wasvalue), andsecretValues.delete(reminix secret-values delete, wassecrets.unset). - Triggers have
lastRunAt(waslastFiredAt); a script’susedBy.startsScriptswasfollowedBy; an environment’susedBywasusage. The eventrun.succeededwasrun.completed. Script ids startscr_. - The CLI:
reminix upload [dir...]uploads a draft (publish --draftis gone), and--dry-runreplaces--plan.
A run that waited for approval now reports when it actually started:
its startedAt (GET /v1/runs/{id}, and a run wherever the SDKs and
the CLI show one) is when it was approved, not when it was requested, and a cancelled long run’s
durationMs counts only the time it ran, never the wait.
Each plan now limits how many runs a workspace has going at once: 1 on
Free, 5 on Pro and 15 on Business, short and long runs together. Of
those, at most 2 can be long runs on Pro and 5 on Business. Starting
one more answers 429 rate_limited with a Retry-After header (a few
seconds for a short run, 30 for a long one) instead of running; the
SDKs and the CLI wait and try again on their own.
A run’s output, error and log (GET /v1/runs/{id},
GET /v1/runs/{id}/log) never show a secret value the run had access
to: printed as it is, or base64- or URL-encoded, it reads [secret].
login in the browser no longer shows Safari’s “This is a non-secure
form” warning after Allow. The page now hands the new token back to
the waiting CLI encrypted to a key only that CLI holds, by a redirect
instead of a form. A CLI from before this change is asked to update.
reminix runwaits through a person’s approval, as the SDKs’rundoes: it prints where to approve the run, then follows it to the end.--no-waitanswers at once instead.- A cancelled run says why, in every client: “Run run_… was cancelled:
The approval was denied” (the run’s
error). The CLI no longer prints “failed: null”. - Files are uploaded without a guessed type; the API takes it from the
file’s name, the same way for every client.
reminix run --fileno longer reads the script first: one file is sent as one id, and the API takes it for an input that is a list of files. - Publishing is one call.
scriptVersions.create(Upload a version) takescreate,name,descriptionandpublish: it can make a new script, rename one, and publish the upload, answering with anapprovallink when a person must approve. Withoutreadme, the folder’sREADME.mdis used.reminix publishuses it, so a name or description changed inreminix.jsonnow reaches the script. reminix initworks out the command the same waypublishdoes, so the two agree on every folder (an entry likemain.pybeside other scripts,pyproject.toml,package.json).
reminix run <slug> --number <n> test-runs version n (a draft).
--version <n> printed the CLI’s own version instead of running, so it
is gone. A run whose output is text prints it as it is, without quotes.
Each release comes with a CHANGELOG.md listing what changed, newest first.
The package page (README, on GitHub, npm and PyPI) shows what the product does with a first real example, and links the guide, the API reference, the changelog and support.
The TypeScript SDK’s guide is at /docs/typescript/, beside /docs/python/ and /docs/cli/.