Built-in MCP & REST tools

Move files to and from your remote machines

Commands return text. Real work also produces checkpoints, rendered images, reports, log bundles, configs, and release artifacts. AI Commander gives your AI a temporary file courier alongside the remote shell: remote_pull brings one file back, and remote_push sends a stored blob to a machine.

Temporary by design. Each file can be up to 100 MiB. A download link lasts 1 hour, and access to the relay blob ends 24 hours after creation. An hourly, retrying cleanup sweep then removes expired bytes; an inaccessible object can remain until a successful sweep. This is a courier, not permanent storage or a backup.

Pull a file from a machine

remote_pull(code, path) reads one regular file at an absolute path on the connected machine, puts its bytes in a temporary relay blob, and returns a blobId plus a download URL. Pulling can work without an account during a session code's first-hour anonymous window.

Your machineone regular file

Temporary relay blobreadable for up to 24 hours

Download URLvalid for 1 hour

# MCP
remote_pull(
  code="gpu-box",
  path="/home/u/aic-jobs/train/metrics.json"
)

# REST
curl -s -X POST https://aicommander.dev/api/v1/pull \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"code":"gpu-box","path":"/home/u/aic-jobs/train/metrics.json"}'

Push a file to a machine

A push has two steps: upload bytes with POST /api/v1/files, then call remote_push(code, blob_id, dest_path) or POST /api/v1/push. Uploading and pushing both require a signed-in account. The agent writes beside the destination and atomically renames the completed file, so an interrupted transfer does not leave a partial replacement.

A push overwrites. If dest_path already names a file, a successful remote_push replaces it atomically. Confirm the destination before pushing; the old contents are not recoverable through AI Commander.

# curl supplies Content-Length when uploading from a file
BLOB_ID=$(curl -s -X POST https://aicommander.dev/api/v1/files \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/octet-stream' \
  --data-binary @release.tar.gz | jq -r .blobId)

curl -s -X POST https://aicommander.dev/api/v1/push \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d "{\"code\":\"api-prod\",\"blob_id\":\"$BLOB_ID\",\"dest_path\":\"/tmp/release.tar.gz\"}"

Limits to design around

Rule	File transfer	What to do
File size	100 MiB maximum	Use your own object storage or artifact registry for larger files.
Source type	One regular file	Archive a directory into one file before pulling it.
Blob access	Expires at 24 hours	Download promptly; an hourly, retrying sweep removes inaccessible expired bytes.
Download link	1 hour	Open or share it while it is fresh.
Push access	Signed-in account	Anonymous session-code callers can pull in the first hour, but cannot upload or push.
Request deadline	About 55 seconds	Move slow or large artifacts directly through storage you control.

Directories do not transfer directly. Create a regular archive first, for example tar -czf /tmp/report.tgz ./report, then pull /tmp/report.tgz. Do not split a large artifact merely to route it through the relay; let the producing job upload to your own storage.

Fair-use quotas

Quotas protect the shared temporary courier. Going over one returns 429 with reason: "rate_limited"; wait for capacity or sign in when anonymous capacity is busy.

Budget	Limit	How it is charged
Machine transfers	60/hour/account	`remote_pull` and `remote_push` share this count.
Caller uploads	60/hour/account	`POST /api/v1/files`; also capped at 5,000 uploads/hour across the relay.
Stored bytes	5 GiB/subject/rolling day	Charged by caller uploads and pulls, which put bytes into the relay; pushes do not charge it again.
Anonymous transfers	Shared 240/hour	All anonymous callers share this count and one shared 5 GiB rolling-day byte pool.

Pulls reserve headroom. The relay cannot know a remote file's size before it arrives, so a pull temporarily reserves the full 100 MiB per-file maximum and settles to the actual size afterward. With less than 100 MiB of rolling-day headroom left, even a smaller pull can be refused; concurrent pulls reserve from the same pool.

Where it helps

GPU and ML artifacts

Collect a small checkpoint, metrics file, or rendered image from a headless GPU machine.

CI build artifacts

Bring back one build output or an archived log bundle from the actual runner.

Configs and releases

Push a config or small release artifact, then run the deployment command.

NAS reports and archives

Pull a health report or one small archive without exposing an inbound port.

Give your AI more than a text result

Install the agent, connect your AI client, and move the first artifact with the built-in courier.

Connect your AI client Read the API reference Explore use cases