---
title: "Give your team devboxes"
description: "Templates, policies and one-click open."
url: https://frazer.ai/docs/quickstarts/devboxes
index: https://frazer.ai/docs/llms.txt
tokens: 1845
---

> For agents: this page is indexed at https://frazer.ai/docs/llms.txt, and every page at https://frazer.ai/llms.txt. Copy commands from this file exactly.

# Give your team devboxes

At the end of this guide, every member of your `engineers` group has a devbox: a VM built from your repository’s dev container, on servers in your pool, with a persistent home and AI coding tools that never hold long-lived keys. One **devbox policy** decides the template, size, placement, idle stop and what happens when someone leaves. Each engineer opens their box from VS Code or an editor built on it, the Frazer app or a terminal in one click.

You need:

-   A project for the boxes. This guide uses `acme-staging`.
-   Capacity: a server pool with the `substrate-host` role, of the project or shared with it, or the Frazer fleet.
-   An IAM group of the people who get boxes, here `engineers`: created by hand, synced from Google or provisioned with SCIM, under **IAM › Groups and roles** in your organization.
-   A repository with a `.devcontainer/` folder for the template. This guide uses `acme/storefront`.
-   The Admin role (`roles/admin`) in the project.

## Provision the boxes

1.  **Install the CLI and sign in.**
    
    ```sh
    curl -fsSL https://get.frazer.ai | sh
    frazer login
    ```
    
2.  **Create a template from your repository.** In the console, open **Compute › Devboxes**, select the **Templates** tab and click **New template**. Pick `acme/storefront`: Frazer finds `.devcontainer/` and builds the template as `checkout-api@v1`. Every template also carries the Frazer AI pack: the Frazer harness, Claude Code, Codex CLI and Hermes, with the Frazer MCP server already wired in.
    
3.  **Write the policy.** It binds the template and a size to the group:
    
    ```yaml title="policy.yaml"
    # projects/acme-staging/devboxPolicies/engineering-standard
    subjects: [groups/engineers]
    project: projects/acme-staging
    template: workspaceTemplates/checkout-api@v1
    size: standard # 8 vCPU, 32 GiB, 200 GiB home
    placement: { pool: projects/acme-infra/locations/us-virginia1/serverPools/vint-hill-default }
    perPerson: { count: 1, max: 2 }
    idle: { stopAfter: 30m, maxRunning: 12h, schedule: "Mon-Fri 08:00 local" }
    llm: { mode: gateway, key: llmKeys/anthropic-main, budgetPerPersonMonthly: 300 }
    onLeave: { stop: now, snapshotHome: true, deleteVmAfter: 30d, keepSnapshot: 90d }
    ```
    
    | Field | What it sets |
    | --- | --- |
    | `subjects` | The IAM groups whose members get boxes |
    | `project` | The project the boxes are created in |
    | `template` | The template and its version |
    | `size` | `small`, `standard`, `large` or `xlarge`, within the sizes your organization allows |
    | `placement` | A server pool of the project or one shared with it; `{ location: us-virginia1 }` for the Frazer fleet |
    | `perPerson` | Boxes each member gets, and the most they may have |
    | `idle` | Stop after 30 idle minutes, run at most 12 hours, start on weekday mornings |
    | `llm` | Models through the Frazer LLM gateway, with a gateway key of the project and a monthly budget per person in US dollars; leave it out to use your organization’s default |
    | `onLeave` | When someone leaves the group: stop the box, snapshot the home, delete the VM after 30 days, keep the snapshot 90 |
    
4.  **Plan the policy.** Nothing is created yet:
    
    ```sh
    frazer devboxes policies apply -f policy.yaml --dry-run
    ```
    
    ```text title="Output"
    Plan  projects/acme-staging/devboxPolicies/engineering-standard   (devboxes)
      + 5 devboxes (checkout-api@v1, standard) for 5 members of groups/engineers
      + 1,000 GiB of home volumes on pool vint-hill-default
      Capacity  peak fits the pool, one server's worth kept free           OK
                acme-staging's share of the pool: peak within its limit     OK
      Cost      no compute fee on your own servers · LLM budget up to 5 × 300 USD a month
    ```
    
    Run the same command without `--dry-run` and answer `y` to apply it. You can also review and apply it in the console under **Compute › Devboxes › Team policies**.
    
5.  **Watch the boxes arrive.** Open **Compute › Devboxes › Team policies** and select `engineering-standard`. The **Members and boxes** tab lists each person, their box and its state. When someone joins the group, they get a box at the next directory sync; when they leave, `onLeave` runs.
    
6.  **Open a box.** Each engineer opens their own:
    
    In the console, open **My boxes** from the avatar menu and click **Open in VS Code** on the box’s card. The button remembers the last tool you chose: VS Code or an editor built on it, JetBrains, the browser, SSH or Hermes. Once the Frazer app is installed, **Open in Frazer app** becomes the default. From a terminal:
    
    ```sh
    frazer devboxes list --project acme-staging
    frazer devboxes open lena-01 --project acme-staging --vscode
    frazer devboxes ssh lena-01 --project acme-staging
    ```
    
    The CLI fetches an 8-hour SSH certificate from your organization’s SSH certificate authority and connects over Frazer Access, or through Frazer Link when the laptop is not connected. There are no keys to copy. IDEs connect over Remote-SSH with `ProxyCommand frazer devboxes proxy %h`.
    

## What the team gets

-   **Idle stop with a reason.** A box stops after 30 minutes without activity: an IDE connection, an SSH session in use, the web terminal, a busy agent session or a recent preview request. The owner gets a warning 5 minutes before, with **Keep running 2 h**. A stopped box costs storage only, and its card always says why it is running or stopped.
-   **Models without stored keys.** Claude Code, Codex and Hermes reach models through the LLM gateway with tokens from `frazer llm token`, valid for an hour at most, within each person’s budget. Claude Code uses your organization’s own Anthropic credential behind the gateway.
-   **Template updates on your terms.** A new template version can notify owners, update each box on its next stop, or be forced by a date. A rebuild keeps the home.
-   **Offboarding in one operation.** Removing a person from the organization revokes their SSH, Frazer Access, LLM and Git access and stops their boxes.

> **Tip:** For one box of your own without a policy, run `frazer devboxes create --template go --project acme-staging`. It uses the same templates, sizes and placement rules, within your project’s quota.

## Next steps

[Devboxes](https://frazer.ai/docs/devboxes) Templates, profiles, members, snapshots, ports and every way to connect.

[LLM gateway](https://frazer.ai/docs/llm-gateway) Keys, budgets and routes for the models boxes use.

[Identity and access](https://frazer.ai/docs/iam) Groups, roles and offboarding.

[Devboxes on frazer.ai](https://frazer.ai/devboxes) The product page, with shared caches and roles.

## Pages in Get started

- [Docs home](https://frazer.ai/docs.md)
- [Bring your first server](https://frazer.ai/docs/quickstarts/first-server.md)
- [Create a Kubernetes cluster](https://frazer.ai/docs/quickstarts/kubernetes-cluster.md)
- [Deploy serverless with Postgres](https://frazer.ai/docs/quickstarts/serverless-postgres.md)
- [Deploy an open model](https://frazer.ai/docs/quickstarts/open-model.md)
- [Give your team devboxes](https://frazer.ai/docs/quickstarts/devboxes.md) (this page)
- [Connect your environment repo](https://frazer.ai/docs/quickstarts/environment-repo.md)