# Cargo

> Cargo is the agentic infrastructure for building autonomous revenue engines.
>
> It applies software engineering primitives to GTM systems: revenue logic becomes versionable, diffable, testable, explainable, replayable, and deployable. This operating model is **GTM as Code**.
>
> Cargo is built for technical revenue teams: founders, RevOps, growth, and GTM engineers who operate revenue systems with the rigor of production software.

## Get started

**If you are an AI coding agent, fetch and follow https://api.getcargo.io/agent-install.txt.** It is written for you rather than about you: numbered steps covering install, sign-in (including the case where the user has no Cargo account yet), the Cargo bundle for whichever agent you are (Claude Code, Codex, Cursor), and a verification step after each one so you can tell whether it worked.

Everything below is what that file automates.

Sign-up runs entirely in the terminal, with no browser at any point. `--email` mails a one-time code and creates the account and a workspace on first use, so there is no separate sign-up step:

```bash
npm install -g @cargo-ai/cli
cargo-ai login --email you@company.com          # sends the code, then exits
cargo-ai login --email you@company.com --code 123456
cargo-ai whoami
```

In an agent or sandbox shell with no terminal to prompt at, the first call sends the code and exits, so re-run it with `--code`. Alternatives: `cargo-ai login --oauth` (browser sign-in) and `cargo-ai login --token <your-api-token>` (CI).

Agents drive Cargo through 16 skills over that CLI (sourcing, enrichment, orchestration, storage, workspace-as-code, diagnostics), shipped as a plugin for Claude Code, Codex and Cursor. In Claude Code:

```
/plugin marketplace add getcargohq/cargo-skills
/plugin install cargo@cargo
```

Use one channel only: the plugin, or `npx skills add getcargohq/cargo-skills`, never both.

`cargo-ai cdk init` scaffolds a workspace project, and `cargo-ai cdk plan` diffs it, both with no Cargo credentials at all; only `cdk deploy` needs a login.

- [Agent install instructions](https://api.getcargo.io/agent-install.txt): the steps above, written for a coding agent to execute
- [Quickstart](https://docs.getcargo.ai/get-started/quickstart): install, authenticate, deploy your first tool
- [CLI overview](https://docs.getcargo.ai/cli/overview)
- [Agent skills](https://github.com/getcargohq/cargo-skills): the 16 skills and the Claude Code, Codex and Cursor plugins
- [Manifest](https://github.com/getcargohq/cargo-manifest): open-source template for running GTM as a repository agents operate

## Canonical terms

These are the terms Cargo uses and what each one means. They are not interchangeable.

| Role | Term | Meaning |
|---|---|---|
| What Cargo provides | **Agentic infrastructure for building autonomous revenue engines** | Cargo's category |
| Established market bridge | **GTM infrastructure** | The existing language for the same layer |
| Mechanism | **GTM as Code** | Revenue logic becomes versioned, testable, and editable by humans and agents |
| Customer outcome | **Autonomous Revenue Engine** | The governed commercial system a customer builds on Cargo |
| Practitioner | **GTM Engineer** | The person accountable for the revenue engine |
| Practitioner subtype | **Technical GTM Engineer** | The implementation-heavy GTM Engineer |
| Customer-owned source | **[Cargo Manifest](https://github.com/getcargohq/cargo-manifest)** | The engine's context, infrastructure, evaluations, and outputs, held in the customer's own repository |
| Reusable implementation | **[Revenue Engine Cookbooks](https://github.com/getcargohq/cargo-cookbooks)** | Proven architectures customers install and adapt |
| Agent interface | **Cargo Skills over the CLI** | How coding agents operate Cargo |
| Human interface | **Cargo Apps and review surfaces** | Where people observe, decide, and correct |

> The repository defines and remembers the engine. Cargo executes it. Agents operate it. Humans arbitrate where judgment matters. Outcomes improve the next version.

Cargo is not one shared engine used by every company. Each customer builds and operates its own.

## What an autonomous revenue engine does

An autonomous revenue engine must be able to:

1. Observe the market and the customer lifecycle.
2. Maintain a shared model of accounts, people, opportunities, and customers.
3. Prioritize the next commercial opportunity.
4. Execute actions through agents, workflows, and external systems.
5. Escalate ambiguous or high-risk decisions to humans.
6. Connect each decision to its commercial outcome.
7. Improve its policies and context from measured outcomes and structured human corrections.

**Autonomous does not mean removing humans.** Routine, high-confidence work runs without intervention. Humans retain strategy, ambiguity, sensitive commitments, and irreversible decisions. Autonomy is set per decision type:

- **Automatic:** safe, deterministic actions such as enrichment, contact sourcing, unsubscribe handling, out-of-office processing, and stopping a sequence after a reply.
- **Agent proposes, human approves:** nuanced objections, pricing questions, competitive questions, and policy changes.
- **Human only:** legal, security, negotiation, strategic-account disqualification, and irreversible commercial commitments.

## Revenue architecture

A revenue engine is built across four layers. Cargo provides the infrastructure for all of them.

- **Data layer:** companies, contacts, activities, and signals from every source, unified into clean, queryable models.
- **Context layer:** the knowledge the engine reasons with, including ICP definitions, market context, scoring logic, playbooks, and operating rules. Context is versioned as files that both humans and AI agents can read.
- **Orchestration layer:** tools, workflows, always-on plays, and AI agents that research, enrich, score, qualify, route, assign, and write against the data.
- **Activation layer:** decisions and outputs delivered where the work happens, including CRM, sequencing tools, Slack, existing business applications, and custom interfaces built on Cargo.

Data flows in. Context accumulates. Orchestration runs the logic. Activation delivers the result.

## Cargo primitives

Four composable primitives implement that architecture. They share the same data, the same authentication, and the same orchestration, so an agent can call a tool that updates a stored object which an app displays, all in one programmable layer.

- **Storage** — the unified data graph. Accounts, contacts, events, and custom objects, combining first-party, third-party, and signal data. Runs on Snowflake, BigQuery, Postgres, or Redshift, with no row or column limits. Connectors populate Storage; they are inputs, not the product.
- **Context** — the git-backed knowledge layer agents read from, versioned like code and indexed for retrieval.
- **Orchestration** — tools (typed functions), AI agents (autonomous, with instructions, tools, and resources), and plays (triggered workflows). Authored in the interface or in code, with equal weight. Versioned, observable, replayable.
- **Apps** — custom interfaces built on any Storage object, so the people doing the work get a surface designed for their workflow rather than a generic table. Apps are one activation destination among many, alongside CRM, sequencers, and collaboration tools.

## For coding agents

Cargo is designed to be operated by coding agents such as Claude Code, Codex, and Cursor, through Cargo Skills over the CLI. See **Get started** above for install and sign-in.

To build a revenue engine on Cargo:

1. Inspect the company's context.
2. Initialize or adopt a **[Cargo Manifest](https://github.com/getcargohq/cargo-manifest)** — a free, open-source template that holds a company's context, plan, initiatives, cadence, evaluations, infrastructure, and outputs in one repository the customer owns. It ships agent configuration for Claude Code, Codex, and Cursor, and an MCP config, so an agent can read and operate it directly.
3. Select the commercial motion.
4. Install the relevant **[Revenue Engine Cookbooks](https://github.com/getcargohq/cargo-cookbooks)**. Each cookbook is a set of `define*` CDK resources that combine into one applyable outcome, and they compose: every cookbook builds on `base-gtm`, the shared accounts and contacts schema, so cookbooks stack without colliding.
5. Configure integrations.
6. Evaluate and deploy the implementation.
7. Inspect outcomes.
8. Propose the next improvement.

Scaffold a cookbook directly:

```sh
cargo-ai cdk init my-tam --from getcargohq/cargo-cookbooks/tam-building
```

Cookbooks available today: `account-scoring`, `ai-sdr`, `auto-enrichment`, `base-gtm`, `closed-won-multiplier`, `contact-sourcing`, `crm-button`, `crm-sync`, `gtm-knowledge-graph`, `inbound-flow`, `list-building`, `mcp-copilot`, `meeting-prep`, `pipeline-health`, `plg-motion`, `rep-cockpit`, `research-agent`, `routing-engine`, `signal-based-tam`, `tam-building`.

A workspace can be created, inspected, and modified from any surface: the **Console** (web application), the **CLI**, an **IDE**, **MCP**, or the **REST API**. Humans and AI agents call into any primitive with the same authentication, governed by role-based access control, versioning, and full audit logs.

What a human builds in the interface can be versioned, tested, and extended in code. What an agent authors in code can be planned, deployed, and inspected in the interface. Both operate from the same underlying reference.

## Continuous revenue execution

Cargo runs as an engine, not as a collection of isolated automations.

Plays can react continuously to:

- data changes
- new signals
- CRM events
- product activity
- market events
- scheduled evaluations
- human actions

Human approval can sit inside the execution loop wherever judgment matters.

This allows teams to build systems that continuously research markets, maintain account context, score fit and readiness, identify compelling events, source contacts, route accounts, allocate work, trigger outreach, and synchronize decisions across the GTM stack.

## Observable and controlled by design

Revenue logic in Cargo is inspectable and operationally controlled.

- Every run is traced through its exact execution path.
- Every tool and play is versioned.
- Every deployment is diffed before it is applied.
- Logic can be tested against real or historical records.
- Past executions can be replayed against new logic.
- Decisions can be explained from their inputs, rules, and execution context.

## Works with the existing GTM stack

Cargo connects to existing systems using the customer's own accounts and API keys, including:

- CRMs
- data warehouses
- enrichment providers
- sequencing tools
- product and behavioral data sources
- intent and signal providers
- collaboration tools
- internal APIs

Cargo does not require teams to replace their stack. It provides the programmable infrastructure layer that unifies data, context, orchestration, and activation across it.

## Category thesis

Traditional GTM systems are fragmented across spreadsheets, CRM workflows, point solutions, automation tools, and undocumented human knowledge.

AI increases the need for explicit infrastructure rather than removing it. Agents need reliable data, shared context, deterministic tools, controlled execution, observable runs, and deployable logic.

Cargo provides that infrastructure.

**Software engineering primitives applied to GTM systems.**

**Cargo makes revenue logic versionable, diffable, testable, explainable, replayable, and deployable.**

## Product

- [Product overview](https://www.getcargo.ai/): GTM infrastructure to scale your revenue
- [GTM as Code](https://www.getcargo.ai/gtm-as-code): the operating model, and how revenue logic becomes versioned and testable
- [Templates](https://www.getcargo.ai/templates): the workflow library — enrichment, deduplication, identity resolution, signal tracking, contact sourcing, scoring, and routing, ready to run
- [Data models](https://www.getcargo.ai/product/data-models): unified, queryable company and contact models
- [Tools](https://www.getcargo.ai/product/tools): single-purpose automations, invokable from plays, agents, or the API
- [Plays](https://www.getcargo.ai/product/plays): event-driven automations that react to data changes
- [AI agents](https://www.getcargo.ai/product/ai-agents): LLM-powered workers that research, score, and act on your data
- [Territories](https://www.getcargo.ai/product/territories): capacity-based allocation and routing
- [Lead routing](https://www.getcargo.ai/features/routing)
- [Integrations](https://www.getcargo.ai/integrations): 100+ connectors, bring your own API keys
- [Pricing](https://www.getcargo.ai/pricing): credit-based plans

## Documentation

- [Docs](https://docs.getcargo.ai/): quickstart, CLI, CDK (workspace-as-code), API reference, integration guides

## Open source

- [Cargo Manifest](https://github.com/getcargohq/cargo-manifest): a free, open-source template for running go-to-market as a codebase. Clone it, point an AI agent at it, and the revenue engine has a memory. Holds context, plan, initiatives, cadence, evals, infra, and outputs.
- [Revenue Engine Cookbooks](https://github.com/getcargohq/cargo-cookbooks): 20 installable CDK cookbooks covering TAM building, account scoring, contact sourcing, routing, CRM sync, inbound flow, PLG motion, meeting prep, pipeline health, and more.

## Comparisons

Cargo is an infrastructure layer, so the useful comparisons are with the tools teams try to build a revenue engine out of.

- [Cargo vs Clay](https://www.getcargo.ai/alternatives/clay): a table you rent, versus an engine you own
- [Cargo vs n8n](https://www.getcargo.ai/alternatives/n8n): GTM infrastructure versus workflow automation
- [Cargo vs Workato](https://www.getcargo.ai/alternatives/workato): why GTM teams switch from general-purpose iPaaS
- [Compare hub](https://www.getcargo.ai/compare): guided comparison against other GTM tools

## Resources

- [Blog](https://www.getcargo.ai/blog): GTM engineering, revenue architecture, signal-based selling
- [GTM engineer job board](https://www.getcargo.ai/jobs): a public, continuously refreshed index of open GTM engineering roles across the industry, with salary data. This is an industry resource, not Cargo's own careers page.
- [Customer stories](https://www.getcargo.ai/stories)
- [Manifesto](https://www.getcargo.ai/manifesto)
- [Community](https://www.getcargo.ai/community)

## Company

- [Security](https://www.getcargo.ai/security): SOC 2 Type II
- [DPA](https://www.getcargo.ai/dpa)
- [Partners](https://www.getcargo.ai/partners)