# Computers

Let your agents read files and run commands on your own computers, and decide what they may do without asking you.

A computer runs a small program called a runner. The runner asks Languid for work and sends back the results. It only connects out, so the computer needs no open port and no public address.

## What gets saved

Every tool call is a record in the agent's space on its PDS. That includes each command an agent runs, its output, and the contents of every file it reads or writes.

The space is private: only you and the agent are members. It is not end-to-end encrypted, though. The PDS operator can read it, Languid's service reads it to run your agent, and your model provider sees whatever the agent sends it.

So keep keys, passwords and private files out of your agents' reach. Don't connect a computer whose files you wouldn't share with them, and deny calls that would read secrets. You can see every saved call on the agent's **Records** page.

When the runner, the tray or setup hits an error, it sends the error message, your operating system and the Languid version to Languid, so we can fix it. Commands, files and output stay out of these reports.

## Add this computer

```sh
languid computer setup
```

Skip this if you connected it when you installed. It shows [what gets saved](#what-gets-saved) and asks before connecting. On macOS, Linux and Windows the runner starts now and again at every login. On other systems, keep this running in a terminal:

```sh
languid computer run
```

## Languid.app on a Mac

On a Mac, `languid computer setup` installs Languid.app in `~/Applications` and runs the runner under it. A snail in the menu bar shows the app is on, and macOS asks for permissions in Languid's name. The menu has:

- an entry for each account signed in on this Mac, with **Pause** or **Resume**, **Open Languid** and **Show Log**
- **Start at Login**, which starts the app, and with it every runner, when you log in
- **Quit Languid**, which stops every runner on this Mac

One runner serves every account signed in on the Mac, so a second account needs no second app. Building the app needs Xcode's command line tools (`xcode-select --install`). Without them, setup runs the runner at login without the menu-bar app.

## The tray on Linux

On a Linux desktop, `languid computer setup` also puts a snail in the system tray. Its menu matches Languid.app's:

- an entry for each account, with **Pause** or **Resume**, **Open Languid** and **Show Log**
- **Start at Login**, which starts every runner when you log in
- **Quit Languid**, which stops every runner on this computer

systemd runs the runners, so they keep working on a computer without a desktop. The tray starts with your desktop. KDE, XFCE, Cinnamon and Ubuntu show it. On other GNOME desktops, install the AppIndicator extension to see it.

## Languid on Windows

Install it from PowerShell:

```powershell
irm https://languid.ai/install.ps1 | iex
```

It needs [Node](https://nodejs.org) 22.18 or newer, and [Git for Windows](https://git-scm.com/download/win), whose bash runs your agents' commands. `languid computer setup` puts the snail in the notification area, with the same menu as Languid.app, and runs the runners from there. Windows support is new. [Windows](/docs/windows) walks through the whole setup.

## Add another computer

Run the install command on that computer and answer y when it asks to connect:

```sh
curl -fsSL https://languid.ai/install | sh
```

Each computer gets a name, which is its hostname unless you pass `--name`. Names are yours alone, so two people can each have a computer called `laptop`.

## A cloud sandbox

A cloud sandbox is a Linux computer that Languid runs for your agents. Subscribe to one on [Billing](/billing). Billing lists it as two items: the computer and an optional volume.

### Computer

$10 a month. The computer shows up as `languid-cloud` on your Computers page. It starts when your agent sends it a call and sleeps after 5 idle minutes. It has Node, Python, git, ripgrep and the usual build tools.

Each time the computer wakes, it starts empty. Add a volume to keep files.

### Volume

$3 a month for 10 GB at `/workspace`, which is also where your agent starts. Files there stay between runs, and Languid saves them every minute while the computer runs and again when it sleeps. Without a volume, files go when the computer sleeps.

A volume needs an active computer subscription.

### Hours

The computer includes 100 hours of running time each calendar month, counted in UTC. Only running time counts; sleeping is free. Billing shows the hours used this month.

Once the 100 hours are used, `languid-cloud` won't start again until the next month, and calls to it fail. Files on your volume stay.

### Canceling

Cancel either item on Billing. It stays active until the end of the period you've paid for, and Billing shows the end date. Until then, Keep it undoes the cancel.

When the computer subscription ends, `languid-cloud` stops. When the volume subscription ends, Languid keeps its files for 14 days, then deletes them. Subscribe again within 14 days to get them back.

## Choose where an agent works

An agent works on the computer you start the chat from. To use a different one:

```sh
languid chat scout --computer laptop
```

In the browser chat, pick the computer under **Works on**. An agent can also name a computer for a single call, and every call runs on exactly one computer.

An agent can only use computers it has been given. Computers you add are given to your existing agents. To give one to an agent you made later:

```sh
languid computer attach laptop --agent scout
```

`languid` offers to do this for you when you open a chat with that agent.

## What runs without asking

Reading files never asks. Before an agent runs a command (`bash`), edits a file (`edit`) or writes one (`write`), it asks you, in pi, in the browser chat or on Discord. You can answer:

- **Allow** runs this one call.
- **Always allow** runs it, and saves a rule so calls like it stop asking. For a command, the rule is as narrow as it can be: allowing `git status` doesn't allow `git push`.
- **Deny** refuses it, and the agent is told so.

Rules are per agent and per computer. You see and change them on the agent's settings page, under **What runs without asking**:

- Set `bash`, `edit` and `write` each to **Ask me first**, **Always allow** or **Never allow**.
- **Commands that run without asking** lists commands by their first words, one per line. `git status` covers `git status -s`, but not `git push`. A chain like `npm test && npm run build` runs only if every part is listed. Anything with `$( )`, backticks, `<` or `>` always asks.
- **Commands it may never run** are refused without asking, even when you've chosen **Allow all** in the chat.

Never beats always, and anything no rule covers asks.

> A command rule is a guard against slips, not a sandbox. Allowing a program allows everything it can do (`find` can delete files), and a deny rule only catches the command as it's written, not one inside a script.

**Allow all** in the browser chat, or `--yes` on `languid run`, skips the questions for that chat or run. Commands you've listed as never allowed are still refused.

## Auto

**Auto**, under **Permissions** in the browser chat, lets a classifier model answer the questions you'd otherwise answer yourself. It approves a call only when the call is reversible and matches what you asked for. Everything else comes to you, in the chat and in your Inbox, as it does with **Ask first**.

These always come to you, and the classifier never sees them:

- spending money, posting, deleting, and sending messages to anyone (email, DMs, Discord, Bluesky)
- pushes, deploys, and anything that touches secrets, keys or credentials
- record writes from your agent's scripts, sharing error reports, and any tool Auto doesn't recognise

For the rest, Languid sends the classifier the tool's name, its arguments (the first 2,000 characters) and your latest message in the thread. Nothing else from the conversation goes, and no tool output. The classifier is Tev1 4B on Together. If it answers anything but two clear yeses, takes longer than 5 seconds, or fails, the call comes to you.

Your rules still decide first: a call they allow runs, and a call they deny is refused.

Each check costs a small amount of credit, about $0.008 per 1,000 checks: what Together charges plus Languid's 5%. It comes out of your Languid credit even when your agent runs on your own API key. With no credit left, Auto checks nothing and every call comes to you.

## Long-running commands

A command that takes longer than 10 seconds keeps running in the background. The agent gets the output so far, and sees the result on its next turn. A background job survives the runner restarting.

## Check and remove computers

```sh
languid computer list
```

```
laptop           up    last seen 2026-11-17T07:58:51.065Z
desktop          up    last seen 2026-11-17T07:58:42.245Z
```

You can also see them on the [Computers](/computers) page. To remove one:

```sh
languid computer remove laptop
```

This revokes its runner, which then stops, and deletes its rules.
