Compute

Run agents, batch jobs, and isolated code without managing servers.

Choose a persistent host for an always-on agent, a job for work that runs to completion, or a code sandbox for short-lived execution. Every workload uses the same Tarka account, credentials and usage view.

Open console Read docs

# keep an agent online
tarka hosts create support-bot --template openclaw
tarka hosts shell support-bot  # a shell inside it

# run a job once and print its logs
tarka jobs create hello --image python:3.12-slim \
  --wait -- python -c 'print("hello")'

# run generated code in a sandbox, then discard it
tarka sandbox run analysis.py
tarka sandbox templates list  # runtimes to pick from

Match the environment to the work.

Use a hosted agent for something that stays online, a batch job for work that finishes, or a sandbox for code you don't trust. Move between them without changing accounts, credentials or model endpoints.

Hosted agentsKeep your agents online.Run an agent from a template, a Compose stack or an image, with private state and Tarka models without an API key.
Batch jobsRun work to completion, off the request path.Give a job an image and a command; it runs once, keeps its logs and stops costing anything when it ends.
Code sandboxesRun generated code in isolation.Start a short-lived Python or Node.js runtime, capture its output, then discard it.

Hosted agents

Keep your agent online without managing its server.

Deploy an OpenClaw or Hermes-style agent with private memory, files, and tools. Tarka manages the runtime and connects it to model inference, speech-to-text, OCR, and text-to-speech services under one account.

Read the agent docs See usage pricing

services:
  agent:
    image: ghcr.io/my-org/my-agent:v1
    environment:
      OPENAI_BASE_URL: http://tarka/v1  # models, no API key
    expose: ["8080"]
 
x-tarka:
  routes:
    - service: agent
      port: 8080
      path: /  # public HTTPS route

tarka login  # once; your coding agent shares it
 
# price the stack, then deploy it
tarka hosts create my-agent \
  --compose compose.yaml --dry-run
tarka hosts create my-agent \
  --compose compose.yaml
 
# check on it, then look inside
tarka hosts get my-agent
tarka hosts list
tarka hosts shell my-agent  # a shell inside the host

Focus on the agent, not the host

Bring the framework, tools, and channels your agent needs. Tarka keeps the runtime online, stores its private state, and gives you one place to manage model access and usage.

Built for always-on work

Run messaging bots, scheduled research, document workflows, and internal automations.
Keep memory, files, secrets, and tool configuration isolated to your tenant.
Use Tarka model, speech, document, and voice APIs without managing separate credentials.
Review runtime status and usage from your Tarka account.

Choose CPU and memory for your workload. Runtime uses prepaid credit; model and utility calls are metered separately at the published prices. Capacity profiles describe resources, not subscription plans or included token allowances.

Choose European or US East placement in the console. US East hosts grow with demand and use persistent encrypted disks. Review the location-specific runtime, disk, and network quote before creating a host; pausing releases compute capacity while retaining billed disk.

Batch jobs Preview · US East

Run work to completion without a server waiting for it.

Give a job a public container image and a command. It runs once in US East and keeps its status and logs. The CLI shows the price and accepts it before the job starts; you pay for the time it ran, with a one-minute minimum.

Model evals: Batch prompts, route checks and quality sweeps against the inference API.
Document work: OCR, extraction, normalisation and indexing runs that call the speech and document models.
Data preparation: Small ETL runs, embedding preparation and artifacts written to a bucket or a repository.
Agent tasks: One-off work that needs a runtime for minutes rather than an agent that stays online.

Read the batch job docs

# prints the price, pins the image to its
# current build, runs it once and prints its logs
tarka jobs create hello --image python:3.12-slim \
  --wait -- python -c 'print("hello")'
 
# your own image at a bigger size
tarka jobs create train \
  --image ghcr.io/my-org/train:v3 \
  --cpu 2000 --memory 4096 --wait
 
# its runs, newest first
tarka jobs runs train

Code sandboxes

A deliberately narrow runtime for generated code.

Create a short-lived Python or Node.js sandbox from an immutable template, execute source, collect stdout and stderr, and let the runtime disappear.

Isolated runtimes
Python 3.12 / 3.13
Node.js 22 / 24
requirements.txt / pyproject.toml / package.json

Read the sandbox docs

from requests import post
 
api = "https://tarka.rest/control/v1/orgs/<org-id>"
auth = {"Authorization": "Bearer tk_live_xxx"}
 
box = post(f"{api}/sandboxes", headers=auth,
           json={"template": "python-3.13"}).json()
# once the sandbox is ready, run code
run = post(f"{api}/sandboxes/{box['id']}:execute",
           headers=auth,
           json={"code": "print(6 * 7)"}).json()
print(run["stdout"])  # 42

# start a sandbox, run the file, print its
# output, then delete the sandbox
tarka sandbox run analysis.py
 
# or run a line of code
tarka sandbox run --template python-3.12 \
  -c 'import sys; print(sys.version)'
 
# keep one open between runs
tarka sandbox create --template node-24 --wait
tarka sandbox exec <sandbox-id> script.js
tarka sandbox delete <sandbox-id>

Available sandbox types.

Open a type to see its dependency rules, execution limits, and what it does not allow.

Type	Runtimes	Resources	Direct egress
Code Runtime Python and Node sandboxes for short evals, code generation, and tool use.	Python 3.12, Python 3.13, Node 22, Node 24	1 vCPU, 1 GiB	Denied

One code-execution surface

Code Sandboxes run a Python or JavaScript program and return its output. Built-in templates provide current language versions; custom templates add a single, validated dependency manifest and prepare it before sandbox creation.

There are no shell commands, arbitrary images, inbound ports, browser sessions, background services, SSH, durable volumes, or GPU controls in this API.

Prepared dependencies without widening the product

Dependency templates are validated and prepared before they can be used. A ready template can be reused across short-lived sandboxes without reinstalling dependencies inside each execution.

Every sandbox uses a fixed 1 vCPU / 1 GiB runtime, a maximum five-minute lifetime, and a maximum 30-second execution. Source and stdin are never persisted.

Create an account to run agents, jobs, and sandboxes.

Create an account Read the compute docs