Help & guide
Everything you need to get jobs running and stay on top of them. New here? Start at the top - the three steps below take about five minutes.
Quick start
1
Connect an agent
Install the small agent on a computer you own. It dials out to ThinkTorch - nothing to open on your firewall.
2
Create a job
Pick a template or fill in a command to run. Add a schedule if you want it to run on its own.
How things work
An agent is a small program you install on any computer you control - a server, a VM, your own PC. It connects out to ThinkTorch and asks "anything for me to run?", so you never expose an inbound port.
On the Agents page, an Admin of the environment generates a one-time onboarding key. Install ThinkTorch Agent from the Microsoft Store on that computer and paste the key into its setup window. For a server nobody signs in to, the Admin gets a one-line PowerShell install alongside the key, which registers it as a Windows service instead. Within a few seconds it shows up as Online. Jobs run on that computer, but ThinkTorch receives each job's command and its output; the Security panel below has the details.
Key. An Admin generates an onboarding key for an environment; the key decides which environment the agent joins.
Install. Install ThinkTorch Agent on the computer and give it the key. The agent dials out to ThinkTorch, so nothing is opened on your firewall.
Registered. The agent registers with the key and starts sending a heartbeat.
Online. While its heartbeat is fresh the agent is Online and can take jobs; if the heartbeat stops it shows as Offline.
A job runs on an agent in the same environment whose tags match the job's.
Run agents on more computers to spread the load or to reach different networks.
An Admin of the environment can move a Windows computer's Task Scheduler tasks into ThinkTorch from that agent's page. Turn on publishing in its Task Scheduler section; once the agent has sent its list, every task outside the Microsoft folder is shown with a verdict: Ready, Ready with a change, Cannot import or Already imported. Choose the ones to import.
An import carries over the task's program, its arguments, its start-in folder and its schedule, at the times the task ran in the computer's time zone. It does not carry over the account the task ran as: the job runs as the agent's account. A task that starts on an event (at boot, at logon, when idle), runs more than one action, or has a setting a job has no equivalent for is not imported, and the agent's page names each reason.
Imported jobs are created off. Disable the original task on its computer before you turn the job on, or the work runs twice. A task's arguments are stored on the job, where everyone who can see the job can read them. Move a secret into a secret parameter.
A Linux server runs the agent as a systemd service, so it keeps running with nobody signed in and comes back after a reboot. It is built for x86-64 with glibc and systemd; agents for macOS, Arm64 and musl (Alpine) are not built.
When an Admin of the environment generates a one-time onboarding key on the Agents page, a Linux block appears beside it, provided this ThinkTorch carries the Linux build. Paste its one-line command into a shell on the server. It needs sudo and asks for the key at a prompt, so the key is never part of the command.
The command takes --server-url (the address of this ThinkTorch),
--name (blank means the host name) and --tags
(linux when left out); the page's command sets them for you. The uninstall command is in that same Linux block,
beside a newly generated key.
A Linux agent runs command jobs and file watches, and file transfers of one file from version 1.2.10 or later. A folder or a pattern as the source runs on Windows agents only. On a Linux agent a move cannot stop another program changing the source while it is copied: if the source's last-write time changed, the run fails and the source is kept. A source that is a symbolic link is read from the file it points to, and a move deletes the link, not that file.
A job is one of three things. Run a program or script: Start an .exe, .bat, .ps1 or .py on an agent and capture its output.
Give it the program or script file - C:\scripts\nightly.bat, C:\scripts\nightly.ps1,
C:\jobs\etl.py or C:\tools\sync.exe - and any arguments. A script gets its
interpreter (cmd.exe, powershell.exe or python)
added for you, and the form shows the exact command line it will run before you save.
File transfer: Copy or move files between folders on an agent.
PowerShell script: Write a PowerShell script here and run it on a Windows agent.
The agent writes it to a folder only its own account and Administrators can write, runs it under Windows PowerShell
(powershell.exe -NoProfile) and deletes it afterwards. Parameters arrive as environment
variables, such as $env:REGION, and a secret is masked in the run's output.
A script runs with the rights of the account the agent runs as, so anyone who can edit the job can do on that computer
whatever that account can.
PowerShell can copy the text of a script into Windows event logs that local users can read, so a secret belongs in a secret parameter, never typed into the script.
It needs agent 1.2.10 or later,
on Windows, and can be up to 65536 characters long.
On a Linux job, give a path like /opt/jobs/etl.py or /opt/jobs/run.sh.
A .py runs under python3 and a .ps1 under pwsh -NoProfile -File;
anything else, a shell script included, is started directly, so a script needs its execute bit
(chmod +x) and a #! first line. No shell sits between:
Args are split at spaces and tabs, double quotes keep words together, and characters such as
$, *, ; and | reach the program as typed.
Not sure where to start? On the Jobs page, start a new job and, under Start from a template, click an example - a health check, a database backup, a cleanup script - and it fills the form in for you. Edit the paths and you're done.
Click Run any time to run a job on demand, whether or not it has a schedule.
An Editor sets a job's parameters in the Parameters section of a saved job's form. Each run gets them as environment variables. A name starts with a letter or underscore and uses only letters, digits and underscores; a job holds at most 50 parameters, and a text value is at most 4000 characters. A few names that decide what a process loads are refused.
A text parameter has a default. Where it is marked Operators may override, a manual run can change it for that run; a webhook URL run can too where Webhook URLs may override too is also ticked. An overridable parameter is input from whoever can run the job, so never make one overridable if it steers where a secret goes, what a program loads or which options it receives.
A secret is stored encrypted, never shown again, and masked as *** in the run's log. It must have at least 8 characters, and a run never overrides a secret. To replace one, press Replace and type the new value; leave it alone to keep the stored one.
Every job can run on a schedule. Pick the style that fits:
Every X minutes / Every X hours - for health checks and frequent tasks.
Daily / Weekly - pick a time and, for weekly, the days. A time or an Advanced cron is read in the job's time zone, which New job sets to your browser's; the Time zone field changes it, to UTC as well.
Advanced - a raw 5-field cron expression if you want full control.
A scheduled job that is switched on shows its next run time on the Jobs list so there are no surprises.
After an outage each overdue job runs once, not once for every run it missed. ThinkTorch then sends one notice to your notifications email and alert webhook, and each job's page lists the runs it skipped.
Only an Editor can add a file watch, in the File watches section of a saved job's form. It runs the job
when a file arrives in a folder on one of the job's agents. A file counts once it has stopped changing for the
settle time (1 to 600 seconds), and each file queues one run. The pattern is like *.csv,
or **/*.csv to include subfolders. An agent that was offline catches up on files from the
last 24 hours. Only local folders on the agent's computer are watched.
The run is claimed by any agent of the job's environment whose tags match, not only the one that saw the file. To keep it on the watching agent, give the job a tag only that agent carries.
A Windows agent watches only from version 1.2.0 or later, and a run whose watch passes the file's path to a parameter is claimed only by an agent at version 1.2.4 or later.
A Linux job watches through a Linux agent, with a folder written as a full path such as
/srv/incoming. A Linux agent watches, and claims such a run, only from version
1.2.10 or later. There the folder and the pattern
match case-sensitively, so *.csv does not take ORDERS.CSV,
and a file or folder whose name starts with a dot is skipped, as Windows skips a hidden file. In a shell
command, quote the variable that carries the path, as in "$INPUT_PATH": unquoted,
a name with a space splits into two words. A job with file watches keeps its platform; remove its watches
before changing it.
Jobs can trigger other jobs when they finish. Open a job, go to Runs after, and add a downstream job to run on success, on failure, or on either.
Example pipeline: Extract → on success → Transform → on success → Load. If Extract fails, the chain stops - and you could add a "notify the team" job that runs on failure instead.
Only an Admin of the environment can create, list or revoke a webhook URL, in the Webhook section of a saved job's form (New webhook URL). The URL is shown once, so copy it then; afterwards the form lists only its token prefix, when it was created and last used, and how often.
A POST to the URL queues one run of that job. Anyone who has the URL can run the job, so keep it like a password.
The body may carry {"parameters": {"NAME": "value"}}, up to
64 KiB, to set for that run the text parameters an Editor opened to
webhook URLs. A body that names parameters but cannot be honoured is refused and nothing runs; any other body is
ignored and the run takes the defaults.
This is not the alert webhook the Alerts panel describes: that is where ThinkTorch posts failure notices, and a webhook URL is where another system posts to start a job.
Set Retries on failure (0–10) on any job on the Jobs page, under More options. If it fails, ThinkTorch re-runs it automatically up to that many times before giving up - great for anything that touches a flaky network.
Worried about a hung command tying up an agent forever? In Settings, set a runaway-job time limit. Any run that goes past it is stopped and marked failed.
During an update or a restart, a job already running on an agent carries on, and the agent keeps trying to reach ThinkTorch. It sends the run's result once ThinkTorch is back, even if the agent restarted in the meantime. Output a job writes while ThinkTorch restarts is missing from that run's log, though the run's result still arrives. For its first minute after it starts again, ThinkTorch does not mark a run failed because its agent has not checked in yet, so a run that was still going is neither failed nor started again on another agent. A schedule that came due meanwhile runs once when ThinkTorch is back, unless the job still has a run queued or going; then that occurrence is skipped. If an agent's computer cannot reach ThinkTorch for more than a minute while ThinkTorch is up, its run is marked failed, and run again if the job allows retries.
In Settings, set a notifications email, an alert webhook (a Slack-style incoming webhook URL, which only the workspace owner sets), or both. When a job fails, ThinkTorch emails that address and posts a one-line message to that webhook (once per job, at most every 10 minutes, so you're not buried).
You'll also see every job whose latest run failed front-and-center on the Attention page, beside the most recent runs, with a link straight to each run's log.
Environments (e.g. Dev, Staging, Prod) keep jobs and agents separate, and let you give teammates access to some but not others. Switch between them with the environment selector.
Tags target a job at specific agents. Tag an agent windows or gpu, add the same
tag to a job, and only matching agents pick it up. Leave a job's tags blank and any online agent can run it.
Give two or more agents in one environment the same tag and they form a pool for jobs with that tag. A queued run goes to the first of them that asks for work, and to that one only. If one of them is off, the others take the new work.
A run that was already going on an agent that stopped, and stays stopped, is marked failed about a minute after the agent last checked in, and it runs again, on any agent of the pool, only if the job's Retries on failure is 1 or more. The default is 0. So a job in a pool must be safe to run on any of its agents.
On the Team page, invite teammates by email. Everyone shares one workspace and one bill, and your plan caps how many people can run or change things: the owner and anyone with Operator access or above count as a seat, while Viewers are free and unlimited. Seats per plan: Free 2, Starter 3, Team 10, Business 30, Enterprise unlimited.
Roles are per environment:
Viewer: See jobs, runs, and logs. Can't run or change anything.
Operator: Viewer, plus run and cancel jobs.
Editor: Operator, plus create, edit, and delete jobs.
Admin: Editor, plus manage agents, this environment, team members, and job webhook URLs.
Pick the least access someone needs.
On the Business and Enterprise plans, the workspace owner can require that everyone else signs in with Continue with Microsoft, using an account from your organization. Turn it on in Settings while you are signed in with Microsoft yourself: the requirement takes your organization from that sign-in, so it can only name one you belong to.
While it is on, password and Google sign-ins to the workspace are refused, nobody but the owner gets a password-reset email, and anyone already signed in another way is signed out. Invites can't be used while it is on, so invite people first and have them add Microsoft from Settings, then turn it on. Agents and webhook URLs keep working.
The owner is not bound by it and keeps a password. If your organization's Microsoft account is lost, the owner signs in with their password, or resets it from Forgot password, and turns the requirement off in Settings.
Ask ThinkTorch is an assistant in the top bar that can look up your environments, jobs, runs, agents and settings, and propose changes. It is offered only when this ThinkTorch has been set up for it, and it works only once the workspace owner turns it on in Settings, or from the assistant's own prompt; until then everyone else sees a note that the owner has not turned it on.
Messages and the workspace details they need go to Anthropic. Your sign-in password, secret parameter values, agent keys, invite links and webhook URLs never do.
It never changes anything by itself. A change arrives as a card, and nothing happens until the signed-in user presses Confirm. The change then runs as that user, through the same checks the page applies, so it can do only what that person's role allows.
Every plan has every feature - you're only paying for scale (how many agents, environments, jobs and seats, and how often a schedule may run). The Free plan is yours forever with no card.
Upgrade or manage your subscription any time on the Billing page. Downgrading never deletes anything you've already created.
Jobs run on your computers, via the agent, against your own files. ThinkTorch receives each job's command and the output the agent sends back, and stores them with the schedule and status. The output is kept for your plan's log-history window after the run finishes (Free 7 days, Starter 30 days, Team 90 days, Business 1 year, Enterprise unlimited), then deleted; the run's status and times stay.
The agent only makes outbound connections, so there's no inbound port to open. Because an agent runs the commands you give it, run it with the least privilege the job needs.
Still stuck, or something missing? Tell us - we read every message.
Send feedback