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

# Quickstart

> Start using agents in under 5 minutes

## Overview

These are the basic steps to getting up and running:

1. Install surfkit
2. Create an agent instance
3. Create a device
4. Launch your agent to solve a task

## Prerequisites

* Docker
* Python >= 3.10
* MacOS or Linux
* Poetry

If you want to create a desktop using Docker, that is all you need. To create a desktop with other providers:

* [Install QEMU](https://docs.hub.agentsea.ai/configuration/qemu) OR [Configure GCP](https://docs.hub.agentsea.ai/configuration/gcp) OR [Configure AWS](https://docs.hub.agentsea.ai/configuration/aws)

<Note>
  {" "}

  If you are using Docker Desktop on MacOS, please update the settings: go to `Settings   | Advanced` and make sure that the checkbox `Allow the default Docker socket to
      be used (requires password)` is checked. Save the settings, apply and restart.{" "}
</Note>

## Install Surfkit

```
pip install surfkit
```

## Run an Agent

**Clone Robbie Gen 2 repository**

```
git clone git@github.com:agentsea/robbie-g2.git && cd robbie-g2
```

**Install dependencies**

```
poetry install
```

**Create a new agent**

```
surfkit create agent -n agent01
```

**List running agents**

```
surfkit list agents
```

<AccordionGroup>
  <Accordion icon="key" title="Automatically add local API keys">
    Agents will prompt you for any keys they need. In order to skip this and automatically add local keys

    ```
    surfkit create agent --local-keys
    ```
  </Accordion>

  <Accordion icon="file" title="View agent logs">
    View all agent logs

    ```
    surfkit logs agent <name>
    ```

    Follow logs

    ```
    surfkit logs agent <name> --follow
    ```
  </Accordion>
</AccordionGroup>

## Create a Device

Now that we've installed our agent, we need to give it a device to use.

The fastest way to get up and running is to use Docker, but the most scalable is to create devices in GCP or AWS.

To create an Ubuntu desktop for our agent to use, select one of the following options ▼

<AccordionGroup>
  <Accordion icon="q" title="Create a local desktop using Docker">
    **Requirements**

    * Docker installed
    * At least 16GB of RAM

    ```
    surfkit create device --provider docker -n desktop01
    ```

    You can also skip the `provider` flag, because `docker` is the default provider:

    ```
    surfkit create device  -n desktop01
    ```
  </Accordion>

  <Accordion icon="q" title="Create a local desktop using Qemu">
    **Requirements**

    * QEMU installed ([macOS](https://www.qemu.org/download/#macos), [linux](https://www.qemu.org/download/#linux))
    * At least 16GB of RAM

    ```
    surfkit create device --provider qemu -n desktop01
    ```
  </Accordion>

  <Accordion icon="google" title="Create a desktop on GCE">
    **Requirements**

    * [gcloud](https://cloud.google.com/sdk/docs/install) installed
    * [Logged in](https://cloud.google.com/sdk/gcloud/reference/auth/application-default/login) to an account with create permissions for GCE\*

    ```
    surfkit create device --provider gce -n desktop01
    ```

    *\* Read [this](/configuration/gcp) for more details on how to configure GCE to create desktop VMs*
  </Accordion>

  <Accordion icon="aws" title="Create a desktop on EC2">
    **Requirements**

    * [Authentication configured](https://docs.aws.amazon.com/cli/v1/userguide/cli-chap-authentication.html) with create permissions for EC2\*

    ```
    surfkit create device --provider ec2 -n desktop01
    ```

    *\* Read [this](/configuration/aws) for more details on how to configure AWS to create desktop VMs*
  </Accordion>
</AccordionGroup>

**List running devices**

```
surfkit list devices
```

## Create a Tracker

Before solving a task, we have the choice to create a [tracker](/taskara/intro#tracker), which is a task server that tracks tasks for us in a Docker container.

```
surfkit create tracker -n tracker01 -r docker
```

## Solve a task

**Use the agent to solve a task on the device**

```
surfkit solve "Search for the most common variety of french duck" \
  --agent agent01 \
  --device desktop01 \
  --tracker tracker01
```

<Note>
  {" "}

  If you don't create tracker explicitly before launching an agent, which you pass
  to the `solve` command via the `--tracker` flag, `surfkit` will ask if you want
  to create a tracker automatically.
</Note>

## What's next

Now that you have a feel for the basics, you can move on to more advanced topics, like learning about all the tools in the surfkit or creating your own agent.

<CardGroup>
  <Card title="Create an Agent" icon="screwdriver-wrench" href="/advanced_tutorial">
    Create your own agent
  </Card>

  <Card title="Learn more" icon="wrench" href="/introduction">
    Learn more about the tools
  </Card>
</CardGroup>