AI writes the script.Now your team can run it, safely.

Today, only the person who wrote a script can run it. Publish it to Reminix and the rest of the team can too: from a form, through the API or as an agent's tool. Who may run it, and with which keys, are settings, not code.

  • Each run on a fresh, isolated machine
  • Keys added on the way out, never in the code
  • Python, shell or Node, as it is

Start freeRead the quickstart

Your terminal
$ cat reminix.json
{
  "slug": "monthly-report",
  "command": "python report.py [--month {month}]",
  "hosts": ["api.stripe.com"]
}
$ reminix publish
Published monthly-report version 1.

Monthly revenue report

Revenue by plan for a month, as a CSV file.

Month (optional)2026-09
Runrevenue-2026-09.csv

monthly-report

  • Finance team may run it
  • Stripe key: read-only
  • Runs on the 1st at 8:00
The monthly-report script as the team sees it: a form with its input and a Run button, and the file the last run wrote, revenue-2026-09.csv, with its settings on a tag.

A script is a command you already run

Python, shell or Node, as it is. Say how it runs, as in python unlock.py {email}, and publish it with reminix publish. The admin key lives in Reminix, which attaches it only to requests to the host you allow. Files the script writes come back as downloads.

unlock-account/unlock.py
import json, sys, urllib.request

email = sys.argv[1]
print(f"unlocking {email}", file=sys.stderr)

# No key here: Reminix adds it to
# requests to api.yourapp.com.
res = urllib.request.urlopen(urllib.request.Request(
    "https://api.yourapp.com/admin/unlock",
    data=json.dumps({"email": email}).encode(),
    headers={"Content-Type": "application/json"},
))
print(res.read().decode())

One publish, every way to run it

The inputs you describe become the form, the API's request and the agent's tool, so every way of running it checks the same things.

nightly-sync

  • Input: date, optional
  • People on your teamA form in the app, made from the inputs
  • Your softwarereminix.run("nightly-sync", inputs)
  • Your terminalreminix run nightly-sync
  • AI agentsA tool over MCP: nightly_sync
  • A timetableA schedule, such as every night at 2:00
  • Something that happenedA trigger, such as an import finishing

The parts that are easy to get wrong

Sharing a script is easy. Sharing it safely is the hard part, and it's what Reminix does for you.

ScriptReminixapi.stripe.comkey addedany other hostno keyholds no key

An API key in the code

You save a key once, and Reminix never shows it again. Reminix attaches each one only to the hosts you allow, and the code never holds it.

Scriptapi.stripe.comhooks.slack.comnot listed: refusedloggedlogged

Code that calls somewhere unexpected

A script has no network until it lists its hosts, and every request it makes is in the run's log.

AgentAwaiting approvalup to a dayan owner or admin approvesruns

An agent running the wrong thing

Set a script so agents' runs wait for an owner or admin. On Business, every run can wait for approval.

v2v3v4 livev5 draftpublish to go liveroll back: publish v3

A change that breaks it

Every change is a new version, and nothing goes live until someone publishes it. Rolling back is publishing the version before.

unlock-accountSupport teamsees it, runs itOther teamsdon't see it

Who can run what

Share a script with your whole workspace, or only with certain teams. The other members don't see it at all, not even through the API.

Where Reminix fits

Most teams run shared scripts in one of these today. Each covers part of the job. Reminix runs the script you already have, keeps its keys out of the code, and lets the whole team run it.

If you useThe gapWith Reminix
Your laptop or a shared serverOnly you can run it, and the keys sit in files the script reads.Anyone you allow can run it, and the script never sees the keys.
GitHub Actions, run by handManual runs need write access to the repository, and the job can read its secrets.A form for people without repository access. Reminix adds keys only to requests to the hosts you allow.
WindmillPython scripts are rewritten around a main() function, and a script can read the secrets it uses.Your command runs as it is, such as python unlock.py {email}, and never sees the keys.
Retool WorkflowsYou rebuild the logic as workflow blocks.You publish the script you already have.
Modal or Val TownThey run your code, and secrets are environment variables your code reads.Who may run it, which runs need approval, and a record of every run, with keys kept out of the code.

Every run on record

The Runs page shows every run across the team: which script, how it ended, how long it took, and whether it came from the app, the API, a schedule or an agent. Each run opens to its inputs, output and log.

Reminix's Runs page: a week of runs across five scripts, each with its status, duration, and whether it came from the app, the API, a schedule, a trigger or an agent.

Your coding agent can do the porting

Connect Claude Code or Codex to Reminix's MCP server and paste a prompt like this one. It writes the script, tests a draft, and publishes only when you say so.

How it works, step by step

Prompt
Publish scripts/refund.py to Reminix as refund-customer. Search the team's scripts first in case one exists. Describe its inputs, write a short README, keep every secret out of the code and declare only the hosts it calls. Make agents' runs wait for approval. Upload it as a draft, test-run it, show me the result, and ask me before publishing.

Start with the free plan

Free for up to 3 authors; Team is $20 per author a month. People who only run scripts are included. No card needed.

Start freeTalk to us

We read every message. Compare the plans