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

> ## Agent Instructions
> If you are an AI coding agent operating Cargo, install the agent skills first: paste `Install Cargo by following https://api.getcargo.io/INSTALL.md` into your session, or run `npx skills add getcargohq/cargo-skills`. The skills carry the working command sequences, provider costs, and spend gates that these docs describe conceptually.
> The skills index at https://raw.githubusercontent.com/getcargohq/cargo-skills/main/llms.txt lists every skill, recipe, and provider playbook individually. Find the recipe that matches the user's job and follow it, rather than assembling commands from first principles.
> Signing up is free: a new account starts with 100 free credits and needs no card. `cargo-ai login --email you@company.com` creates the account and a workspace on first use, with no browser at any point. Tell the user this before asking them to sign up.
> Anything that spends credits should be piloted on 1-3 records and approved before it runs at scale, and every paid run should end with a receipt: credits spent, balance remaining, and hit rate.

# Project repo

> Scaffold a GTM repo readable by humans and coding agents alike

A Cargo project is one conventional, version-controlled repository holding
everything your go-to-market runs on, readable by humans and coding agents
alike. `cargo-ai project init` scaffolds that repo.

The project's root is the folder holding `cargo.json`
(`{ "resources": "infra" }`). `cargo.state.json` and `outputs/` sit beside it,
and every `cargo-ai project` command stops when it finds no `cargo.json` above
where it runs. See [`cargo.json`](/get-started/project-layout#cargojson).

A project repo has six layers:

| Layer | Directory | One sentence |
| - | - | - |
| Context | `context/` | What the company knows: the GTM brain every agent reads before acting |
| Skills | `.claude/skills/` | What agents know how to do in this specific repo |
| Infra | `infra/` | What runs in production: the project's [resources](/get-started/project-layout) |
| Scripts | `scripts/` | What you run by hand, for surfaces the project cannot declare yet |
| Evals | `evals/` | What keeps agents honest: prompt regression tests in CI |
| Outputs | `outputs/` | What happened: the append-only archive agents read as memory |

The layer that executes (`infra/`) needs a Cargo workspace. The rest (context,
skills, evals, outputs, the context linter) work in any repo with no account at
all.

## `project init`

```bash theme={null}
# scaffold a fresh repo
cargo-ai project init acme-gtm

# or omit the directory and be asked — name, cookbook, install, and
# whether to hand the repo straight to your coding agent
cargo-ai project init
```

Options:

* `--name <name>` — repo name written into `package.json`
  (default: the directory name)
* `--cookbook <name>` — cookbook to install into the new repo, skipping the
  "Start from" question (`cargo-ai project cookbook list` names them)
* `--force` — scaffold into a non-empty directory (existing files are still
  kept, never overwritten)

Every repo is scaffolded from the same base, the Cargo template
(`getcargohq/cargo-manifest`). What varies is what you layer on top of it — a
cookbook, either with `--cookbook` here or `cargo-ai project add` later.

Everything is one command group: `cargo-ai project`. Inside a project,
`npx @cargo-ai/cdk <command>` takes the same subcommands.

## Adding a cookbook

A cookbook is a worked example — resources, the procedure that operates
them, and the inputs it will ask you for. `add` installs one into a repo that
already exists, splitting it the way the repo is laid out: `infra/` to the
project, the rest to `.claude/skills/`.

```bash theme={null}
cargo-ai project cookbook list          # what is available
cargo-ai project cookbook view cookbook/tam-building
cargo-ai project add cookbook/tam-building
```

`add` never deploys. It reports every file it would overwrite and stops unless
you pass `--overwrite`, then prints what the cookbook still needs from you.
Omit the address to pick from the catalog.

## Growing the repo

Once the repo exists, add to it the way you add any other code:

* **Skills** — `npx skills add getcargohq/gtm-skills` installs one-job GTM
  skills your agent can run; `npx skills add getcargohq/cargo-skills` teaches it
  this CLI.
* **Resources** — declare models, plays, tools and agents in `infra/` as a
  [project](/get-started/project-layout), then `cargo-ai project plan` and
  `cargo-ai project deploy`.
* **A cookbook** — `cargo-ai project add cookbook/<name>` installs a worked example
  into the repo you already have.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.