Download Tbench Actions for your device

Tbench Actions / 0.3.0

One command. A desktop app. Your organization.

The current v0.3.0-k21 release includes browser device login, a local desktop control panel and the GitHub workflow worker. Windows creates a Start-menu shortcut; Mac creates a per-user application. Use tbench-worker push for a session tied to your own push. Desktop-managed sessions remain an optional workflow.

Desktop and browser-login guide · Current verified release metadata

This download is the GitHub workflow worker. The independent tbench actions and tbench verify source profile has a separate policy and enrollment guide; do not use one profile’s credentials or commands for the other.

Git, GitHub CLI, Python with Tk, and Docker are prerequisites for the desktop installation.

Previous releases and native installer options

Previous portable bundle / v0.2.2-k2

515 KB · v0.2.2-k2 · Contains the Ed25519-signed worker. The ZIP is not OS-publisher signed.

Download previous CLI bundle Release provenance

Verify this download

Compare the SHA-256 of the downloaded ZIP before extracting. Open START-HERE.html for review and verification steps. The offline verifier requires Python with cryptography already installed; setup still needs network access for dependencies.

ZIP SHA-256
eb5324bc74637fa0c6e56aba560a370a502a3e355a9b6f15b5d0db7eee548992

Native installer release requirements

The one-command installation creates local desktop launchers around the verified Python runtime. Downloadable MSI, PKG and DMG installers are a separate publisher-signed distribution path and are not offered here.

Native Windows installers require publisher signing and clean-machine installation tests before release; macOS PKG/DMG and ARM execution require separate qualification.

Mac host support / Signed client pilot

The current signed release selects Ubuntu 24.04 x64 on Intel Macs or ARM64 on Apple Silicon through Docker Desktop. Choose macOS below for the verified installation command. Actual MacBook installation, Keychain and job lifecycle qualification are still required.

Native macOS and Xcode jobs use the separate Apple-Silicon disposable-VM source pilot. Review the Mac execution and qualification guide.

Your runner, once your organization is approved.

your-team / applicationWalkthrough

Execution trail 4 steps

Your computerBounded execution session

Client workspace01 / 04

Connect your organization

An owner approves the company and repository scope.

Tbench / organization

Organization approval

GitHub App · selected repositories

Contributor membership verified

Approved workflow and runner group

Step explained

Setup walkthrough · Installation

Open the installation guide

From approved access to your first push.

Connect the organization once, install the signed client, then start each local run from your repository with GitHub CLI identity.

One command / your GitHub identity

Install once. Push from your terminal.

Install the signed client once. From your repository, run tbench-worker push. It pushes your branch, starts a session for that push on this computer and follows the job through cleanup.

Operating system

WindowsPowerShell + Docker DesktopLinuxBash + Linux DockermacOS pilotIntel / Apple Silicon + Docker Desktop

Have the essentials ready.
- GitHub CLIConnect your contributor account with gh auth login.
- GitInstalled and available in your terminal.
- Python 3.12+Use a Python distribution with Tk for the desktop app. The installer checks the runtime.
- Docker Engine 28+A native Linux x64 or ARM64 engine. Windows and macOS hosts use Docker Desktop in Linux-container mode.
- Approved organizationAn owner or admin approves browser device sign-in for your private repository scope.
Setup verifies the signed release and builds images for this device’s native Linux Docker architecture. It never starts a job.
Connect an approved repository.
Your organization installs the GitHub App for the approved repository and configures its workflow and runner group. The local push command verifies your existing GitHub CLI contributor identity.
Review organization setup
Installing the tool alone grants no repository access. Your GitHub identity, repository approval, exact commit and workflow scope are checked before the temporary session starts.

Review. Run. Confirm.

Open PowerShell, copy the command below and run it there. You do not need to download or double-click a script file.

Install and set up Tbench

& { $ErrorActionPreference = 'Stop'; $tbenchPython = Get-Command py.exe -CommandType Application -ErrorAction SilentlyContinue | Select-Object -First 1; $tbenchPythonArgs = @('-3'); if (-not $tbenchPython) { $tbenchPython = Get-Command python.exe -CommandType Application -ErrorAction SilentlyContinue | Select-Object -First 1; $tbenchPythonArgs = @() }; if (-not $tbenchPython) { throw 'Python 3.12+ was not found. Install Python with Tcl/Tk support from python.org, enable its PATH option, then reopen PowerShell and retry.' }; $tbenchSetup = Join-Path ([IO.Path]::GetTempPath()) ([guid]::NewGuid().ToString() + '.py'); try { Invoke-WebRequest -MaximumRedirection 0 -TimeoutSec 30 -Uri 'https://actions.tbench.in/releases/v0.3.0-k21/bootstrap.py' -OutFile $tbenchSetup; if ((Get-FileHash -Algorithm SHA256 -LiteralPath $tbenchSetup).Hash.ToLower() -ne '5d8eccf181156df76027270e0e760f17331b35d3233b0bca64a0d89bcab3a2cc') { throw 'Bootstrap checksum mismatch' }; & $tbenchPython.Source @tbenchPythonArgs $tbenchSetup --mode worker --desktop; if ($LASTEXITCODE -ne 0) { throw 'Tbench setup failed' } } finally { if (Test-Path -LiteralPath $tbenchSetup) { Remove-Item -LiteralPath $tbenchSetup } } }

Setup checks the bootstrap checksum and signed manifest. Run the local push command from your checkout with your existing GitHub CLI login. Desktop controls are also available in Start → Tbench → Tbench Actions on Windows or ~/Applications/Tbench Actions on Mac.

Check your GitHub login

gh auth status

If you need to connect GitHub CLI, run gh auth login and complete GitHub’s browser approval. The local push flow uses that identity and does not require a separate Tbench account login in your terminal.

Prefer to download and review the setup script?

Download Windows setup script Review installer source

Guided setup

./tbench-worker-setup.ps1 --desktop

Save it as tbench-worker-setup.ps1, review it, then run the guided setup command in PowerShell from that folder. Opening the file in a text editor only displays its source; it does not install Tbench.

This installs the same release as the one-command setup. It does not enroll a device, enable a service, change PATH or begin a paid subscription.

Prefer downloading and reviewing in your terminal?

Download installer

Invoke-WebRequest -Uri https://actions.tbench.in/releases/v0.3.0-k21/install.ps1 -OutFile tbench-worker-setup.ps1

Review installer

Get-Content ./tbench-worker-setup.ps1

Push. Run here. Follow the result.

From your repository checkout, this command pushes the current branch and admits only its matching jobs to a bounded session on this computer. Keep Docker running while the command follows the stages and confirms cleanup. Another developer’s push does not borrow your laptop.

Push and run on this computer

tbench-worker push

Add --ai-profile /path/to/review.json for an owner-approved AI review and repair profile. Required tests, source scope, model access and attempt limits are configured separately from submitted code.

Managed devices and desktop browser sign-in

For a separately approved managed-device workflow, an owner or admin can authorize the desktop app’s device code. Its session stops after eight hours or ten jobs. Credentials use Windows encryption, macOS Keychain or an owner-private Linux file.

Browser sign-in from the CLI

tbench-worker auth login

Start a bounded worker session

tbench-worker serve --max-hours 8 --max-jobs 10

Use tbench-worker auth status to check the connection and tbench-worker auth logout to revoke the device after its active work is resolved. Sign-out preserves job history and recovery journals.

Command not found or setup needs another check?

Setup prints the installed launcher path; it does not automatically change PATH. Use that path directly, or add its folder to PATH yourself and reopen your terminal.

Push using the default launcher path

& "$env:USERPROFILE\.local\bin\tbench-worker.cmd" push

Run the diagnostic command when the launcher is on PATH. If Docker is stopped or enrollment is missing, follow the local diagnostic before retrying.

Check local prerequisites

tbench-worker check

Verify the signed worker payload.

Use actions.tbench.in for downloads. The current immutable desktop/worker release is v0.3.0-k21. Setup pins its bootstrap hash and verifies the Ed25519 manifest before installing its 21 allowlisted files. Historical release bytes remain unchanged.

That verifies the worker payload’s origin and integrity; it is not Windows Authenticode, Microsoft Store approval or Apple Developer ID notarization. Do not disable SmartScreen or Gatekeeper, import a self-signed root certificate, or bypass your organization’s policies.

Downloading and opening a script do not install software. Run the verified install command in your terminal. The GitHub App connects the approved repository; tbench-worker push uses your existing GitHub CLI identity, pushes your branch and opens a temporary session for its matching jobs on this computer.

Already using an older release? Stop the worker and confirm cleanup before an explicitly reviewed reinstall. The new trust-key channel is not a silent or cross-signed auto-update.

Change the eligible job’s runner. Keep its steps.

-    runs-on: ubuntu-latest
+    runs-on: tbench-2vcpu-ubuntu-2404

GitHub resolves runs-on: by matching labels. Choose jobs that fit the supported operating system, resource and network profile; GitHub keeps the workflow orchestration.

You define builds, tests and review commands in .github/workflows/*.yml . Tbench supplies the execution capacity.

For a manual run, use one command.

gh workflow run ci.yml --repo ORGANIZATION/REPOSITORY --ref main

Enable workflow_dispatch for this separate managed-device command. For the local push flow, run tbench-worker push and configure the approved run-specific group and labels. The invoking computer executes only its matching push session.

Choose jobs that fit the device profile.

Current device profile · trusted private GitHub Actions jobs
Workload	Availability	Conditions
Existing shell and JavaScript-action jobs	Supported profile	Ubuntu 24.04 x64; dependencies must fit the approved image, network policy and resource caps.
Push, PR, manual, scheduled and matrix workflows	Approved scope	GitHub keeps scheduling, needs, matrices, logs and artifacts. Private, same-repository source and explicit workflow/event/ref approval are required.
npm and Python package downloads	Opt-in	GitHub-only networking by default. The package-registries profile additionally permits npm and PyPI; arbitrary hosts remain blocked.
Execution duration and local availability	Bounded	Ten-minute job deadline. The owner must keep the device awake and serving; offline devices leave work queued, with no paid fallback.
Docker builds, container actions and services	Not supported	No Docker socket, privileged runner, service container or nested Docker build is exposed.
Mac hosts and native Linux ARM64 jobs	Signed client pilot	The current desktop/worker release supports Ubuntu x64 on Intel Macs and Ubuntu ARM64 on Apple Silicon or ARM64 Linux. The macOS installation command is available; actual MacBook installation, Keychain and job lifecycle qualification are pending.
Native Windows/macOS/Xcode/GPU jobs	Not qualified	These require separate execution backends and image qualification. Windows hosts serve Linux x64 jobs through Docker Desktop; a Mac host also runs Linux jobs, not native macOS jobs.
Public forks and hostile code	Not admitted	Use only private code and workflows trusted by the device owner. Docker is not a hostile-code microVM boundary.
Managed cache and hosted overflow	Not available	Persistent managed caches and paid hosted overflow are outside the current device plan.
Self-serve organization connect	Beta	Connect the GitHub App for your approved organization and private repository scope, then enroll devices through guided setup.

Runner labels

Each label names a size, image and architecture. Unsuffixed labels use the published x64 profile. Explicit -arm64 labels are for the signed ARM64 client pilot, with hardware qualification tracked separately. Choose the smallest class that fits the job.

Label	Write this in the workflow	Release status
`tbench-2vcpu-ubuntu-2404`	`runs-on: tbench-2vcpu-ubuntu-2404`	Published x64
`tbench-2vcpu-ubuntu-2404-arm64`	`runs-on: tbench-2vcpu-ubuntu-2404-arm64`	Signed ARM64 client pilot
`tbench-4vcpu-ubuntu-2404`	`runs-on: tbench-4vcpu-ubuntu-2404`	Published x64
`tbench-4vcpu-ubuntu-2404-arm64`	`runs-on: tbench-4vcpu-ubuntu-2404-arm64`	Signed ARM64 client pilot
`tbench-8vcpu-ubuntu-2404`	`runs-on: tbench-8vcpu-ubuntu-2404`	Published x64
`tbench-8vcpu-ubuntu-2404-arm64`	`runs-on: tbench-8vcpu-ubuntu-2404-arm64`	Signed ARM64 client pilot
`tbench-16vcpu-ubuntu-2404`	`runs-on: tbench-16vcpu-ubuntu-2404`	Published x64
`tbench-16vcpu-ubuntu-2404-arm64`	`runs-on: tbench-16vcpu-ubuntu-2404-arm64`	Signed ARM64 client pilot

The signed desktop/worker client runs native Linux x64 or ARM64 Docker profiles. Mac and ARM64 are client pilots with physical-device qualification pending; the previous portable ZIP remains x64-only. Native macOS/Xcode, Windows and GPU jobs need separately qualified execution backends.

What the device profile includes

Explicitly approved scope. Repository access, workflow admission and enrollment are separate from installing the tools. No payment or automatic top-up is started by setup.
Bring your own compute. Your contributor seat covers local execution with no per-minute Tbench charge. Your organization supplies the hardware and covers its power, maintenance and infrastructure costs.
Owner-selected resource caps. Default job capacity is 2 CPUs within a 4096 MiB device memory budget. A separately bounded proxy can use up to 0.25 CPU. Adjust existing CPU and memory flags only after reviewing the device’s capacity.
Scoped device credentials. The worker receives revocable installation access and short-lived runner configuration. GitHub App signing keys stay on the hosted broker, not your device.
Ephemeral, one-job runners. The runner registers for one job and deregisters when it ends. Nothing persists between jobs on the runner itself after confirmed cleanup. Interrupted cleanup blocks new work until recovery.

Plan your deployment.

Data handling. GitHub retains repository data, workflow logs and configured artifacts. Tbench receives execution metadata. Keep secrets out of logs and review the inputs sent to external actions or model providers.
Compute ownership. Your organization supplies the machine; Tbench supplies runner registration and the control plane.
Build state. Runners are ephemeral. Persistent managed dependency and build caches are outside this plan.
Workload trust. Containers share the host kernel. Run trusted private code; public and untrusted fork jobs are not admitted by this profile.
The signed desktop/worker client runs native Linux x64 or ARM64 Docker profiles. Mac and ARM64 are client pilots with physical-device qualification pending; the previous portable ZIP remains x64-only. Native macOS/Xcode, Windows and GPU jobs need separately qualified execution backends.
Default network access is GitHub-only. Opt in to TBENCH_EGRESS_PROFILE=package-registries for the npm and PyPI registries; arbitrary hosts remain blocked.
Repository-scoped runners can pick up another same-label job in that repository. Use only private code and workflows the device owner trusts; a workflow allowlist is not hostile-code isolation.

Authoring a Terminal-Bench task? Read the Experts setup guide. Select a verifier workload when your project requires evaluation.

Your workflows. Your chosen device.

Connect your organization

One command. A desktop app. Your organization.

Previous portable bundle / v0.2.2-k2

Native installer release requirements

Mac host support / Signed client pilot

Your runner, once your organization is approved.

Connect your organization

From approved access to your first push.

Install once. Push from your terminal.

Have the essentials ready.

Connect an approved repository.

Review. Run. Confirm.

Push. Run here. Follow the result.

Verify the signed worker payload.

Change the eligible job’s runner. Keep its steps.

For a manual run, use one command.

Choose jobs that fit the device profile.

Runner labels

What the device profile includes

Plan your deployment.

Point one repository at it.