# AgilityCLI (Command Line Interface)

> Source: https://agilitycms.com/docs/developers/cli

The Agility CLI lets you download an instance's content and structure to local files (`pull`) and synchronize content and structure directly between two instances (`push`, also available as `sync`).

https://vimeo.com/1239515909/5332becf3d

**Version:** install the latest published version. See the [npm versions page](https://www.npmjs.com/package/@agility/cli?activeTab=versions).

![Code and content take the same path to production through DEV, QA, UAT and PROD. Code moves with a deploy; content moves with agility sync and is checked with agility verify.](https://cdn.aglty.io/agility-cms-docs/images/developer/docs-diagram-content-ops-two-pipelines.svg)

## 1. Important considerations

### Chained multi-instance syncs (A → B → C)

After syncing instance A to B, the CDN publishing tasks triggered on B must finish **before** you use B as the source for a sync to C. Using B as a source too early can cause **data loss**. There is currently no way to confirm that publishing tasks have completed; a future release will block syncing from an instance with pending or errored tasks. For now, allow time between chained syncs.

### Start with a blank target

The sync creates source→target mappings on its first run and cannot incorporate content that already exists independently on the target. For reliable environment parity, sync into a **blank** target instance.

### Synced items get new Content IDs

Items created on the target during a sync receive **new** Content IDs; they do not carry the source's IDs across.

## 2. Install

The CLI is published on npm as `@agility/cli`. Run it with `npx`, so there's nothing to install globally, replacing `{version}` with the version you want. If you want the `agility` command on your PATH, as the examples below use it, install it globally instead:

```
# run without a global install (recommended)
npx @agility/cli@{version} pull

# or install globally so the agility command is on your PATH
npm install -g @agility/cli@{version}
```

The latest published version is listed on the [npm versions page](https://www.npmjs.com/package/@agility/cli?activeTab=versions). Don't run npm with `sudo`: if a global install fails with a permissions error, install Node with a version manager (such as nvm) instead. In CI, use a pinned, project-local install, as shown in the [CI/CD Integration Guide](https://agilitycms.com/docs/developers/cli-ci-cd-integration-guide).

## 3. Authentication

Authentication happens automatically the first time you run `pull`, `push`, or `sync`. You can also authenticate explicitly:

```
agility login
```

This opens a browser window for secure authentication.

```
agility logout
```

You must have an **Org Admin**, **Instance Admin**, or **Manager** role to perform CLI operations.

### Non-interactive authentication (CI/CD)

Where a browser login isn't possible, authenticate with a **Personal Access Token (PAT)** instead of the OAuth browser flow. To create one, follow [Create a Personal Access Token](/docs/developers/create-personal-access-token): sign in with `agility login`, then create the token with one `curl` call. For the rules that apply to tokens, see [Personal Access Tokens](/docs/developers/personal-access-tokens).

Provide the token via the `--token` flag or the `AGILITY_TOKEN` environment variable, and run with `--headless=true`:

```
agility pull --sourceGuid="abc123" --token="your-pat-here" --headless=true
```

## 4. Environment configuration

You can set default values in an optional `.env` file so you don't have to pass them on every command. Command-line flags override environment values.

```
AGILITY_GUID=your-source-instance-guid
AGILITY_TARGET_GUID=your-target-instance-guid
AGILITY_LOCALES=en-us,fr-ca
AGILITY_TOKEN=your-personal-access-token
```

Each key below matches a flag. In CLI 1.2.1 only the first four take effect, and only from a `.env` file, except `AGILITY_TOKEN`, which is also read from the process environment. For the others, pass the flag on the command line. See [CLI command reference](/docs/developers/cli-reference) for the details:

| Environment variable | Flag | Takes effect in 1.2.1? |
| --- | --- | --- |
| AGILITY_GUID | --sourceGuid | Yes |
| AGILITY_TARGET_GUID | --targetGuid | Yes |
| AGILITY_LOCALES | --locales | Yes |
| AGILITY_WEBSITE | --channel | No: the flag default replaces it |
| AGILITY_ELEMENTS | --elements | No: the flag default replaces it |
| AGILITY_MODELS | --models | No: the flag default replaces it |
| AGILITY_TOKEN | --token | Yes |
| AGILITY_OVERWRITE | --overwrite | No: the flag default replaces it |
| AGILITY_VERBOSE | --verbose | No: the flag default replaces it |
| AGILITY_HEADLESS | --headless | No: the flag default replaces it |

## 5. Commands overview

The CLI's main commands are `pull` and `push` (also available as `sync`). It also has `reverse-sync`, `verify`, `workflows`, and `login` and `logout` (see Section 15).

**`pull`**: Downloads an instance's content and structure (models, containers, templates, content, pages, assets, galleries) to local files under `agility-files/`. Use it to take a local snapshot of an instance, for inspection, backup, or as the first half of a manual pull-then-push migration.

**`push`**: In 1.2.1, `push` is another name for `sync`. It reads both the source and the target instance itself, rather than uploading files from a previous `pull`. See Section 7.

**`sync`**: Sets up a persistent relationship between two instances that are intended to be synced together in a unidirectional way. This migrates content and models directly from a source instance to a target instance in a single command, maintaining reference mappings so the two stay correlated across repeated runs. This is the command most migrations use, and the bulk of this guide covers it. `pull` and `sync` share most of the same options; the conflict-resolution flag (`--overwrite`) and the publish-state flag (`--autoPublish`) apply specifically to `sync` (and `push`).

**`verify`**: New in 1.2.0. Compares a synced target with its source and reports every difference: content and field values, component order on every page, the page tree, models, containers, page models, assets, galleries and the mappings. It pulls both instances fresh and never writes to either one. See [agility verify](/docs/developers/cli-verify).

Authentication runs automatically the first time you use any of them (see Section 3).

Each command works against an instance identified by its **GUID**. Find it in the Agility manager under **Settings → API Keys**, labelled *GUID*.

![CI concepts and their Agility CLI match: a dry run is agility sync --preflight, a deploy is agility sync, a smoke test is agility verify, the CI job result is --headless with --jsonSummary, and promoting a build is a sync from the UAT instance to the PROD instance.](https://cdn.aglty.io/agility-cms-docs/images/developer/docs-diagram-content-ops-matching-gates.svg)

## 6. Pull command

Downloads content from an Agility instance to local files.

```
agility pull [options]
```

| Option | Type | Default | Description |
| --- | --- | --- | --- |
| --sourceGuid | string | — | Instance GUID to pull from. Provide this flag or set AGILITY_GUID |
| --token | string | — | Personal Access Token for non-interactive auth; falls back to AGILITY_TOKEN |
| --locales | string | all (auto-detected) | Locale(s) to pull. Comma-separated for multiple |
| --channel | string | website | Channel to pull; falls back to AGILITY_WEBSITE |
| --elements | string | all | Comma-separated subset: Models,Galleries,Assets,Containers,Content,Templates,Pages,Sitemaps,UrlRedirections |
| --models | comma-separated list | none | Pull only the specified models and their direct content |
| --models-with-deps | comma-separated list | none | Pull the specified models with their full dependency tree: content, pages, assets, galleries, templates, containers |
| --verbose=true | boolean | true | Detailed console output |
| --headless=true | boolean | false | No interactive UI; log to file only |

#### Examples

```
# Pull everything for a locale
agility pull --sourceGuid="abc123" --locales="en-us"

# Pull specific elements only
agility pull --sourceGuid="abc123" --locales="en-us" --elements="Models,Content"
```

Downloaded files are written under the local `agility-files/` directory (see Section 10).

## 7. Push command

In 1.2.1, `push` is another name for `sync`: it runs the same two-pass sync from a source instance to a target instance, and reads both instances itself. It does not upload files from a previous `pull`.

```
agility push --sourceGuid=<sourceGuid> --targetGuid=<targetGuid> [options]
```

`push` takes the same options as `sync` (see 8.1). For every option in 1.2.1, see [agility sync and agility push](/docs/developers/cli-sync).

Like `sync`, `push` keeps its working files and reference mappings under the local `agility-files/` directory (see Sections 9 and 10).

## 8. Sync command

Synchronizes content and structure from a **source** instance to a **target** instance, with dependency resolution via reference mappings. This is the most fully-featured command.

```
agility sync --sourceGuid=<sourceGuid> --targetGuid=<targetGuid> [options]
```

The sync is **forward-only**: it creates and updates entities on the target to match the source, but never deletes or unpublishes anything on the target.

Sync works from the local `agility-files/` directory and maintains reference mappings under `agility-files/mappings/` (see Sections 9 and 10).

### 8.1 Flags

| Option | Type | Default | Description |
| --- | --- | --- | --- |
| --sourceGuid | string | — | Source instance GUID (copy from). Provide this flag or set AGILITY_GUID |
| --targetGuid | string | required | Target instance GUID, copy to (or set AGILITY_TARGET_GUID) |
| --token | string | — | PAT for non-interactive auth; falls back to AGILITY_TOKEN |
| --locales | string | all (auto-detected) | Locale(s) to sync. Comma-separated for multiple |
| --channel | string | website | Channel to sync; falls back to AGILITY_WEBSITE |
| --elements | string | all | Comma-separated subset: Models,Galleries,Assets,Containers,Content,Templates,Pages,Sitemaps,UrlRedirections |
| --models | comma-separated list | none | Sync only the specified models and their direct content |
| --models-with-deps | comma-separated list | none | Sync the specified models with their full dependency tree: content, pages, assets, galleries, templates, containers |
| --overwrite=true | boolean | false | Resolve conflicts by overwriting the conflicted target items with the source versions. See 8.6 |
| --autoPublish | string | disabled | Mirror source publish state. Values: content, pages, both. See 8.5 |
| --preflight | boolean | false | Dry-run validation: reports what would be synced and surfaces conflicts without making any changes. See 8.8 |
| --verbose=true | boolean | true | Detailed console output |
| --headless=true | boolean | false | No interactive UI; log to file only |

If the target does not support every locale present on the source, the sync stops cleanly before making any changes; there is no partial push.

### 8.2 What gets synced

| Entity | What's covered |
| --- | --- |
| Content Models | Reference name, display name, all field types (Text, HTML, Content, ImageAttachment, etc.), field labels, help text, validation, defaults, content definition type |
| Component / Module Models | Same coverage as content models, used for page modules |
| Containers (shared, top-level) | Reference name, view name, model assignment, default sort, listing settings, publish state |
| Containers (nested ContentView lists) | The internal containers Agility creates for linked-content fields on a model |
| Page Templates | Layout and module zone definitions |
| Pages | Name, title, menu text, hierarchy/parentage, SEO (meta description, keywords, robots), visibility flags (menu, sitemap), zone module assignments with content references, channel association |
| Content Items | All field values for every field type, content state (staging/published), item order, linked-content references, asset references, locale assignment |
| Galleries / Media Groupings | Name, description, parent grouping |
| Assets / Media files | Binary content (any file type), filename, container path, content type, size |
| Image focal points | The focal-point coordinate used by templates to crop images |
| URL redirections | Page/URL redirect entries |

Linked content is copied across, and the mappings between related items are preserved.

### 8.3 Sync mechanics

| Operation | Behaviour |
| --- | --- |
| Initial sync (fresh target) | Every entity type is created and a mapping recorded for each |
| Re-sync, no changes | Safe to re-run: everything is skipped, nothing is written |
| Source-side update | Pushed to the target; the mapping is updated to the new version |
| Conflict (both sides changed) | Flagged and skipped, unless --overwrite=true is set (see 8.6) |
| Mapping integrity | One-to-one source↔target mapping is preserved across re-runs |
| Multi-locale | Each source locale syncs independently, provided the target has the same locale registered |

Content is matched by versionID on subsequent syncs: only newer versions are pushed, and duplicates are skipped.

### 8.4 Selective sync

For partial syncs, scope the run rather than syncing the whole instance:

- `--elements="Models,Content"`: limit to specific entity types.
- `--models="Model1,Model2"`: sync only those content models and their direct content.
- `--models-with-deps="Model1,Model2"`: sync those models with their **full** dependency tree: content, pages, assets, galleries, templates, and containers.

```
# Sync only models
agility sync --sourceGuid="abc123" --targetGuid="def456" --models="Model1,Model2"

# Sync models plus their dependencies
agility sync --sourceGuid="abc123" --targetGuid="def456" --models-with-deps="Model1,Model2"
```

### 8.5 Publish state and --autoPublish

By default, synced content lands on the target in **staging**, regardless of its state on the source. The target site or app won't surface a new item until it has been published. Use `--autoPublish` to carry the source's publish state across.

#### Modes

| Value | Behaviour |
| --- | --- |
| --autoPublish or --autoPublish=both | Publish both content items and pages (default when no value is given) |
| --autoPublish=content | Publish only content items (skip pages) |
| --autoPublish=pages | Publish only pages (skip content items) |

#### How it works

1. Tracks which items were successfully pushed to the target.
2. Checks each item's publish state in the source; only items published in the source are eligible.
3. Publishes the eligible items on the target via the batch workflow API, per locale.
4. Updates reference mappings after publishing.

Only items published in the source are published on the target; **staging-only items stay in staging**. Auto-publish applies to `sync` only (not `pull`). Failed items aren't published, and any errors are listed in the final summary.

**The sync never unpublishes anything.** `--autoPublish` only ever adds a publish; it never removes one, in any mode.

#### Edge case: a published item with a newer staging version

In Agility, an item can be published **and** have a more recent unpublished (staging) version at the same time. This happens whenever someone publishes an item, then begins editing it again without re-publishing.

The sync always copies the **latest** version. When the latest version is the staging one, that's what's transferred, so `--autoPublish` finds it in a non-published state and leaves the target item in staging.

The result can be surprising: pages that look "published" on the source arrive in the target's **Ready to Publish** list even with `--autoPublish` set. This is expected; the source's latest version was a staging edit, and that's the version that synced.

**To resolve:** publish the staging version on the **source** first, so the source's latest version is the published one. Then re-sync with `--autoPublish`, and the target will publish that version.

### 8.6 Conflict resolution and --overwrite

A **conflict** occurs when the same entity has changed on **both** the source and the target since the last sync. By default the CLI skips conflicted entities and preserves the target's version, logging a `Conflict detected, use --overwrite to force` message.

`--overwrite=true` resolves conflicts in favour of the source: for each conflicted entity, it overwrites the target version with the source version.

#### What --overwrite does

- Resolves conflicts across all synced entity types: content items, pages, containers, models, templates, galleries, and assets. A conflict is when an item changed on both sides; `--overwrite` pushes the source version.
- Overwrites only the target entities genuinely in conflict; unchanged entities are still skipped.

#### What --overwrite does not do

- It does **not** re-push entities that haven't changed; re-running with `--overwrite=true` on an already up-to-date sync still writes nothing.
- It does **not** change publish state; that's governed separately by `--autoPublish`.
- It does **not** delete or unpublish anything on the target; the sync is always forward-only.

**Overwrite doesn't destroy the live published version.** Resolving a conflict writes the source's content into the target item's **staging** version; the currently-published version stays live and unchanged. The new version only replaces what's live if you also pass `--autoPublish`, and even then the previous content is retained as a prior entry in the target's version history, not deleted.

Use `--overwrite=true` after a sync has reported `Conflict detected` and you've decided the source should win.

### 8.7 What the CLI does NOT do

The sync only moves content **forward**. The following are out of scope and must be handled manually on the target (see Section 13).

| Not synced | Detail |
| --- | --- |
| Source-side deletions and unpublishes | If anything is deleted or unpublished on the source after a sync (a model, content item, page, container, template, asset, or gallery), the target's copy stays in place. The CLI does not detect the removal. Applies to published→staging unpublishes, soft deletes, and hard deletes. |
| Pre-existing target content | Content that already exists independently on the target cannot be remapped or replaced; sync into a blank target for parity. |
| Version history | Only the current version of an entity is applied on the target; prior versions are not recreated as target history. |

### 8.8 Preflight mode

`--preflight` runs a dry-run validation before the actual sync. It reports what would be synced and surfaces any conflicts, then stops without writing anything to the target.

```
agility sync --sourceGuid="abc123" --targetGuid="def456" --preflight
```

Use it to inspect the expected outcome of a sync, especially before an initial population or when you suspect conflicts, without committing any changes.

**Preflight does not surface every possible error.** It's intended to show what the CLI expects to do, it shows the user what content, pages, models, containers, and assets will be synced with the command inputted, and it can surface content conflicts for existing mapped content. It can't catch errors that only occur during a real sync, network issues, or permission-related errors.

**Required fields (1.2.0 and later).** The CLI checks each content item against the target's model before it sends it. With `--preflight`, an item that's missing a required field is listed with the action `invalid` and a warning that a real sync would skip it; `invalid` items don't change the exit code. In a real sync, the item is skipped and reported as a failure that names the model and the missing fields. See [Preflight validation](/docs/developers/cli-sync#preflight-validation).

## 9. Reference mappings

Reference mappings record the relationship between each source entity and its corresponding target entity. They are what make sync dependency-aware and re-runnable.

### How they work

1. **Discovery:** the CLI catalogs entities on both instances.
2. **Mapping creation:** establishes source↔target relationships using identification strategies.
3. **Dependency resolution:** transforms entity references (model IDs, asset URLs, template references) during the push so target entities point at the right target dependencies.

### Why they matter

- **Dependency resolution:** pages reference the correct target templates; field references are rewritten to target IDs.
- **Conflict prevention:** prevents duplicate creation and enables safe, incremental re-runs.
- **Multi-instance support:** each source→target pair has its own mapping set, supporting chained pipelines.

### Lifecycle

- **Automatic loading:** existing mappings are loaded when a sync starts, then preserved and extended.
- **Incremental updates:** new entities are added as discovered; existing rows are updated when the target changes.
- **Manual management:** mapping files can be deleted to reset the relationship for a pair.

## 10. File structure

The CLI reads and writes everything under a local `agility-files/` directory. This layout is shared by `pull`, `push`, and `sync`:

```
agility-files/
├── {instance-guid}/
│   ├── models/              # Content models
│   ├── containers/          # Content containers
│   ├── templates/           # Page templates
│   ├── galleries/           # Galleries
│   ├── assets/              # Media files
│   │   └── json/            # Asset metadata
│   ├── sitemaps/            # Sitemap definitions
│   └── {locale}/            # Per-locale content
│       ├── item/            # Content items
│       ├── list/            # Content lists
│       ├── page/            # Pages
│       ├── sitemap/         # Flat sitemap
│       ├── nestedsitemap/   # Nested sitemap structure
│       ├── urlredirections/ # URL redirections
│       └── state/           # Sync state and tokens
├── mappings/                # Reference mappings (sync only)
└── logs/                    # Operation logs
```

### Mappings (created during sync only)

Reference mappings are written **only** when you run `sync` (or `push`, its other name); `pull` doesn't create them. They're stored per source→target pair:

```
agility-files/
└── mappings/
    └── {sourceGuid}-{targetGuid}/
        ├── models/          # Content model mappings
        ├── containers/      # Container mappings
        ├── templates/       # Template mappings
        ├── galleries/       # Gallery mappings
        ├── assets/          # Asset mappings
        └── {locale}/        # Per-locale mappings
            ├── item/        # Content item mappings
            └── page/        # Page mappings
```

## 11. Reading the sync log

### Line markers

| Marker | Meaning |
| --- | --- |
| ● | Action performed (created, updated, downloaded) |
| ○ | Action skipped (already up to date, or no change needed) |
| ✗ | Action failed, or a conflict was detected |
| ⚠️ | Warning: non-fatal, informational |
| 📋 | Decision note (e.g. auto-publish reasoning) |

### Phases (in order)

1. Authentication and source pull
2. Target pull (for comparison)
3. Asset galleries and media groupings
4. Media files and asset metadata
5. Content models and field definitions
6. Content containers and views
7. Page templates and layouts
8. Content items (per locale)
9. Pages and page hierarchy (per locale)

Each push phase ends with a summary line:

```
Push <phase>: N successful, M skipped, K failed
```

For the authoritative per-phase outcome, rely on these per-phase summary lines.

### Useful lines to look for

| To find out… | Look for |
| --- | --- |
| Total runtime | Total time: |
| Whether the sync succeeded | ✓ Sync completed successfully or ✗ Sync completed with errors |
| Conflicts | Conflict detected |
| Per-locale content decisions | [FilterContent] Decision summary: N create, M update, K skip, L conflict |
| Per-phase totals | Push : … successful, … skipped, … failed |

## 12. Typical workflows

### Initial target population

Brand-new (blank) target, established source. First sync to populate the target.

```
agility sync --sourceGuid="abc123" --targetGuid="def456" --autoPublish
```

`--autoPublish` ensures content published on the source arrives published on the target, rather than waiting in staging.

**Expect:** a longer runtime, many `created` lines, mapping files filling out, and `✓ Sync completed successfully` at the end.

**Verify:** target entity counts line up with the source; key pages render correctly; mappings are one-to-one.

### Ongoing sync

```
agility sync --sourceGuid="abc123" --targetGuid="def456"
```

Add `--autoPublish` if the target should immediately reflect the source's publish state.

**Expect:** a short runtime, mostly `up to date, skipping`, and `updated` lines only where the source genuinely changed.

**Verify:** spot-check the items you know changed; confirm `0 failed` in every phase.

### Resolving conflicts

If a sync reports `Conflict detected`, both sides changed the same entities since the last sync:

- **Source wins** (the usual case): re-run with `--overwrite=true`.
- **Target wins:** do nothing; the target's version is already preserved.

```
agility sync --sourceGuid="abc123" --targetGuid="def456" --overwrite=true
```

## 13. Manual post-sync procedures

Because the items in Section 8.7 aren't synced, handle them on the target as follows.

- **Remove content deleted on the source:** the CLI doesn't propagate deletions; delete the corresponding target entities in the Agility manager.
- **Unpublish content unpublished on the source:** manually unpublish the affected target items in the Agility manager.

## 14. Troubleshooting & FAQs

### Sync stops immediately reporting missing locales

The source has a locale the target doesn't support. Add the locale on the target, or use `--locales` to restrict the sync to supported locales.

### A locale's pages aren't pushed

The locale is registered on the source but has no published sitemap. If expected, ignore; otherwise publish the locale's sitemap on the source.

### Conflict detected on a page, content item, or container

Both the source and target changed that entity since the last sync. The sync skips it and preserves the target version. To let the source win, re-run with `--overwrite=true`.

### Sync halts with a model conflict error

If the CLI detects a structural incompatibility between a content model on the source and its counterpart on the target that it cannot auto-resolve, the sync stops and logs a model conflict error. This is different from the content conflicts that `--overwrite=true` handles; it requires manual resolution.

### Pages published on the source land in Ready to Publish on the target, even with --autoPublish

Those pages were published, but each also had a more recent **staging** version. The sync copies the latest version (the staging one), so `--autoPublish` correctly leaves the target item in staging. This is expected. To fix it, publish the staging version on the **source** first, then re-sync. See Section 8.5.

### Known issues and limits

Some problems in the Agility CLI 1.2.1 are known and open, and a few limits won't change. They include changes on older non-USA instances not reaching the Fetch API, pulls that wait on a stuck update, and images that point at another instance's CDN. Each one, with what to do about it, is listed in [Known issues and limits](/docs/developers/cli-reference#known-issues-and-limits).

### FAQs

#### Can I pull/sync only selected content lists?

The first sync copies all content. Subsequent syncs bring across only newer versions via the established mappings; content is updated by versionID and duplicates are skipped.

#### Can I sync a specific subset of models and their content?

Yes. Use `--models-with-deps` to target one or more models and bring forward the staged or published content under them.

#### How are linked content and mappings handled?

Linked content is copied across, and the mappings between related items are preserved.

#### What state does synced content land in?

Staging, regardless of the source state. Use `--autoPublish` to publish items that were published in the source. Staging-only items stay staged; unpublished or deleted source items are not pulled across.

#### Which version is synced: staging or published?

The most recent version is synced regardless of its published status on the source, and it lands on the target in staging. Only that current version is applied; version history is **not** carried to the target.

#### If source content was published and then modified/staged, which version syncs?

The most recent version always syncs, regardless of staging or published state. See Section 8.5 for why this can leave a published page in staging on the target.

#### Does the CLI reconcile/replace existing target content, or append?

Neither; pre-existing target content cannot be remapped or replaced. The initial sync establishes a new mapping, so syncing into a blank instance is strongly recommended for environment parity.

#### Do synced items have the same Content ID as the source?

No. All synced content is created with new Content IDs on the target.

## 15. Command reference

For every command and option in CLI 1.2.1, one page per command, see the [CLI command reference](/docs/developers/cli-reference). It also covers sign-in, the `.env` settings the CLI reads, exit codes and the `--jsonSummary` report for CI.

- [agility pull](/docs/developers/cli-pull)
- [agility sync and agility push](/docs/developers/cli-sync)
- [agility reverse-sync](/docs/developers/cli-reverse-sync)
- [agility verify](/docs/developers/cli-verify)
- [agility workflows](/docs/developers/cli-workflows)
- [agility login and agility logout](/docs/developers/cli-login-logout)

The reference is checked against version 1.2.1. Where this page and the reference differ, the reference describes 1.2.1. For example, in 1.2.1 `push` is another name for `sync` and reads both instances itself, and `--rootPath`, `--preview` and `--baseUrl` are not options.

To test the site that uses your Agility content in CI, including a models-only pull to catch model changes, see [Test Your Agility Integration in CI](/docs/developers/test-agility-integration-in-ci).

---

## Related pages

- [Content Fetch API](https://agilitycms.com/docs/developers/content-fetch-api.md)
- [Content Sync API](https://agilitycms.com/docs/developers/content-sync-api.md)
- [Content Management API](https://agilitycms.com/docs/developers/content-management-api.md)
- [GraphQL API](https://agilitycms.com/docs/developers/graphql-api.md)
- [CLI - CI/CD Integration Guide](https://agilitycms.com/docs/developers/cli-ci-cd-integration-guide.md)
- [Testing on Swagger](https://agilitycms.com/docs/developers/testing-on-swagger.md)
- [GraphQL & Rest API Filtering](https://agilitycms.com/docs/developers/graphql-operators.md)
- [Personal Access Tokens](https://agilitycms.com/docs/developers/personal-access-tokens.md)
- [Content Delivery & CDN Architecture](https://agilitycms.com/docs/developers/content-delivery-and-cdn-architecture.md)
- [Typed GraphQL with TypeScript and Next.js](https://agilitycms.com/docs/developers/typed-graphql-typescript-nextjs.md)
- [Image Transformation Reference](https://agilitycms.com/docs/developers/image-transformation-reference.md)
- [Fetch API Status Codes and Caching](https://agilitycms.com/docs/developers/fetch-api-status-codes-and-caching.md)
- [Field Types and What the APIs Return](https://agilitycms.com/docs/developers/field-types-api-reference.md)
- [Content Sync Explained](https://agilitycms.com/docs/developers/content-sync-explained.md)
- [Agility CLI Command Reference](https://agilitycms.com/docs/developers/cli-reference.md)
- [CLI Reference: agility pull](https://agilitycms.com/docs/developers/cli-pull.md)
- [CLI Reference: agility sync and push](https://agilitycms.com/docs/developers/cli-sync.md)
- [CLI Reference: agility reverse-sync](https://agilitycms.com/docs/developers/cli-reverse-sync.md)
- [CLI Reference: agility workflows](https://agilitycms.com/docs/developers/cli-workflows.md)
- [CLI Reference: agility login and logout](https://agilitycms.com/docs/developers/cli-login-logout.md)
- [Test Your Agility Integration in CI](https://agilitycms.com/docs/developers/test-agility-integration-in-ci.md)
- [CLI Reference: agility verify](https://agilitycms.com/docs/developers/cli-verify.md)
- [Create a Personal Access Token with the API](https://agilitycms.com/docs/developers/create-personal-access-token.md)
- [Manage Personal Access Tokens in Agility](https://agilitycms.com/docs/developers/manage-personal-access-tokens.md)

Index of every docs page: https://agilitycms.com/docs/llms.txt
