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

# Quickstart

> Connect the Autonomy MCP to your client and run your first task.

## Prerequisites

Before you connect, make sure you have:

* An **Autonomy account** with access to Studio.
* At least one **repository connected** to Autonomy (the Autonomy GitHub App installed on it). New repos start in `PENDING_INITIALIZATION` - the [setup step](#run-your-first-task) walks you through getting one to `READY`.
* An MCP client - **Claude Code** or **Claude Desktop**.

## The two MCP servers

You connect **two** MCP servers. They do different jobs and complement each other:

| Server          | What it is          | What it does                                                                 |
| --------------- | ------------------- | ---------------------------------------------------------------------------- |
| `autonomy`      | The **product** MCP | Does the work - projects, tasks, setup, Full Mode.                           |
| `autonomy-docs` | The **docs** MCP    | Answers "how do I…" against this documentation, without leaving your editor. |

Wiring both means your agent can *read the docs* and *act on the platform* in the same session.

## Connect from Studio (recommended)

The fastest path is the **"Connect your AI tools (MCP)"** card in Studio's User Settings. It gives a copyable **Claude Code** command, pointed at the hosted URL and wired to the OAuth login/consent flow.

## Connect manually

<Tabs>
  <Tab title="Claude Code">
    ```bash theme={null}
    # Product MCP (drives the platform - runs the OAuth login flow)
    claude mcp add --transport http autonomy https://mcp.autonomyai.io/mcp

    # Docs MCP (queries these docs)
    claude mcp add --transport http autonomy-docs https://docs.autonomyai.io/_mcp/server
    ```
  </Tab>

  <Tab title="Claude Desktop">
    Add both servers to your client's MCP config:

    ```json theme={null}
    {
      "mcpServers": {
        "autonomy": {
          "url": "https://mcp.autonomyai.io/mcp"
        },
        "autonomy-docs": {
          "url": "https://docs.autonomyai.io/_mcp/server"
        }
      }
    }
    ```
  </Tab>
</Tabs>

On first use of the `autonomy` server your client opens a browser to sign in and consent (your existing Autonomy identity and project permissions apply). The docs server is read-only and needs no auth.

## Run your first task

Once connected, ask your agent to drive it:

<Steps>
  <Step title="Pick a project">
    Call `list_projects` and choose a `project_id` + `workspace_id`. If a just-connected repo isn't `READY`, call `initialize_project` and poll `list_projects` until it is.
  </Step>

  <Step title="Start the task">
    `start_task(project_id, workspace_id, instruction)` returns a `task_id` immediately - the work runs in the background.
  </Step>

  <Step title="Watch it">
    Poll `get_task(project_id, task_id)` until the status is terminal or it needs input. Read the agent's work with `get_task_messages` and the code changes with `get_task_pr_diff`.
  </Step>

  <Step title="Ship it">
    When you've approved the changes, `complete_task` opens or updates the pull request for your developers.
  </Step>
</Steps>

<Tip>
  If you're unsure how to drive a flow, the product MCP ships built-in guides: call `load_autonomy_skill` (names: `setup`, `full-mode`, `tasks`, `troubleshooting`) or use the `/autonomy-getting-started` prompt.
</Tip>

## A full example, start to finish

Here's a complete run - from a plain-English ask to an open pull request. You talk to your agent in natural language; under the hood it makes these calls:

```
You:   "In my storefront repo, add a dark-mode toggle to the settings page."

Agent: list_projects()
       → picks project_id=… , workspace_id=…  (status READY)

       start_task(project_id, workspace_id,
                  instruction="Add a dark-mode toggle to the settings page")
       → task_id=…  (status: running)

       get_task(project_id, task_id)   # polled until it settles
       → status: awaiting_input / completed

       get_task_pr_diff(project_id, task_id)
       → shows the changed files for you to review

You:   "Looks good - ship it."

Agent: complete_task(project_id, task_id)
       → opens the pull request for your developers ✅
```

With the [skill](https://docs.autonomyai.io) installed, your agent runs this sequence correctly on its own - including waiting for your approval before `complete_task`.

## Next steps

<CardGroup cols={2}>
  <Card title="Projects & workspaces" icon="folder" href="/concepts/projects-and-workspaces" />

  <Card title="Run a coding task" icon="play" href="/concepts/tasks" />

  <Card title="Full Mode" icon="layer-group" href="/concepts/full-mode" />

  <Card title="Troubleshooting" icon="life-ring" href="/troubleshooting" />
</CardGroup>