> ## Documentation Index
> Fetch the complete documentation index at: https://docs.celesto.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Choose computer size

> Configure CPU, memory, disk size, and templates when creating a Celesto computer so coding agents have enough resources for builds, packages, and apps.

You can choose a named computer size before a Celesto computer starts. Start with Nano for small jobs, then move to Small, Standard, or Large when your agent builds code, installs packages, opens large files, or runs a web app.

Root disk and workspace storage are both durable, but they serve different jobs. Use `disk_size_mb` for operating system and runtime space. Use CelestoFS workspace storage for large project files, repositories, datasets, and artifacts. See [Petabyte-scale storage for AI agent sandboxes](/celesto-sdk/features/petabyte-storage).

## Start with a template

A template is a ready-made starting setup for a computer. It includes an operating system, useful tools, and default resource sizes.

Use `coding-agent` when your workflow needs common coding tools. Use the template defaults when you are running quick scripts or trying Celesto for the first time.

<CodeGroup>
  ```python Python theme={null}
  from celesto import Computer


  templates = Computer.list_templates()

  for template in templates:
      print(
          f"{template['id']}: "
          f"{template['default_vcpus']} CPU, "
          f"{template['default_ram_mb']} MB memory"
      )
  ```

  ```ts TypeScript theme={null}
  import { Computer } from "@celestoai/sdk";

  const templates = await Computer.listTemplates();

  for (const template of templates) {
    console.log(
      `${template.id}: ${template.defaultVcpus} CPU, ${template.defaultRamMb} MB memory`,
    );
  }
  ```

  ```bash CLI theme={null}
  celesto computer templates
  ```
</CodeGroup>

## Choose a named size

CPU and memory must match one of these named sizes:

| Size     |    CPU | Memory |
| -------- | -----: | -----: |
| Nano     | 1 vCPU | 512 MB |
| Small    | 1 vCPU |   1 GB |
| Standard | 2 vCPU |   4 GB |
| Large    | 4 vCPU |  12 GB |

Your Celesto plan controls which sizes you can create:

| Plan    | Available sizes              |
| ------- | ---------------------------- |
| Free    | Nano                         |
| Nano    | Nano                         |
| Builder | Nano, Small, Standard, Large |
| Growth  | Nano, Small, Standard, Large |

Omit both CPU and memory to use the template default. When you set them explicitly, choose both values from the same row. Mixed combinations such as 2 vCPU with 2 GB memory are rejected.

<ParamField body="cpus" type="integer">
  CPU value from a named size. Use together with the matching `memory` value.
</ParamField>

<ParamField body="memory" type="integer">
  Memory in MB from a named size. Use together with the matching `cpus` value.
</ParamField>

<ParamField body="disk" type="integer | string">
  Root disk storage as MB or a string such as `"20gb"`. More root disk helps when tools, package managers, or system-level build steps need more local runtime space.
</ParamField>

<ParamField body="disk_size_mb" type="integer">
  Root disk storage inside the computer in MB. Range: 512-20480 MB. For large workspace files, use CelestoFS instead of increasing root disk size.
</ParamField>

<ParamField body="template_id" type="string" default="scratch">
  Ready-made starting setup for the computer. Use `coding-agent` when your agent needs coding tools already installed.
</ParamField>

## Create a larger computer

Create a larger computer when the default template does not have enough room for the job. This example creates a Standard `coding-agent` computer with 2 CPUs, 4096 MB of memory, and 20480 MB of disk space.

<CodeGroup>
  ```python Python theme={null}
  from celesto import Computer


  computer = Computer(
      template_id="coding-agent",
      cpus=2,
      memory=4096,
      disk="20gb",
  )

  print(computer.name)
  print(f"{computer.vcpus} CPU")
  print(f"{computer.ram_mb} MB memory")
  print(f"{computer.disk_size_mb} MB disk")

  computer.delete()
  ```

  ```ts TypeScript theme={null}
  import { Computer } from "@celestoai/sdk";

  const computer = await Computer.create({
    templateId: "coding-agent",
    cpus: 2,
    memory: 4096,
    disk: "20gb",
  });

  console.log(computer.name);
  console.log(`${computer.vcpus} CPU`);
  console.log(`${computer.ramMb} MB memory`);
  console.log(`${computer.diskSizeMb} MB disk`);

  await computer.delete();
  ```

  ```bash CLI theme={null}
  celesto computer create --template coding-agent --cpus 2 --memory 4096 --disk-size-mb 20480
  ```
</CodeGroup>

<Check>
  The response shows the CPU, memory, and disk size assigned to the new computer.
</Check>

## Pick a starting size

Use the smallest computer that can finish the job. Increase the setting that matches the problem you see.

| Workload                           | Start with                                          |
| ---------------------------------- | --------------------------------------------------- |
| Quick shell commands               | Nano or template defaults                           |
| Coding agent with package installs | Standard `coding-agent`                             |
| Large repository builds            | Large, plus CelestoFS workspace storage             |
| Data processing or notebooks       | Standard or Large, plus CelestoFS workspace storage |
| Hosted preview app                 | Standard, plus port publishing                      |

<Tip>
  Move to the next named size when builds are slow or programs run out of memory. Increase root disk when system tools run out of runtime space, and use CelestoFS for large workspace files.
</Tip>