Cargo Skills — GTM engineering for AI coding agents
Nineteen agent skills that turn Claude Code, Codex, Cursor, Grok Bot, Grok Build, and any skills.sh-compatible agent into a go-to-market engineering workstation: build lead lists, find and verify emails and phone numbers, enrich companies and contacts through provider waterfalls, score and qualify leads, write outreach, sync to your CRM, and monitor buying signals (job changes, funding rounds, tech-stack and hiring intent) — then make any of it a scheduled, always-on workflow.
They run on the Cargo CLI against Cargo, the AI-native revenue infrastructure: 150+ integrations (HubSpot, Salesforce, Attio, Pipedrive, Outreach, Salesloft, Lemlist, Smartlead, Instantly, Snowflake, BigQuery, Slack, Google Ads, Meta and LinkedIn audiences, and more), 50+ credits-based data providers with per-action costs documented up front, models and SQL over workspace storage, AI agents with RAG, alerting, hosted apps, and GTM as Code projects that declare a whole workspace.```
██████ ████ █████ ██████ ██████
██ ░ ██ ██░ ██ ██ ██ ░ ██ ██░
██ ██████░ █████ ░ ██ ███ ██ ██░
██ ██ ██░ ██ ██ ██ ██░ ██ ██░
██████ ██ ██░ ██ ██ ██████░ ██████░
░░░░░░ ░░ ░░ ░░ ░░ ░░░░░░ ░░░░░░
Tell your agent what you want and it picks the skill:
> *"Find me 50 VPs of Sales at Series B fintechs and verify their emails."*
> *"Enrich this CSV with company size, funding stage, and tech stack."*
> *"Alert me when my enrichment error rate goes above 5%."*
> *"Set up our whole workspace as code so I can review it in a PR."*
**A new account starts with 100 free credits, valid for its first 30 days, and no card.** At the prices in pricing.json that is ~500 leads sourced (`salesNavigator.searchLeads`, 0.2 a lead), ~1,000 verified-email enrichments (`aiArk.enrichPerson`, 0.1), or ~50 fully enriched contacts (`waterfall.enrichContact`, 2), and the two-minute quickstart demo returns 25 rows for at most 1.25 of them. Your agent can install, sign you up, and hand back a real list in one turn.
Machine-readable index for agents and crawlers: `llms.txt`.
## Install
### Fastest — paste one line into your agent
Paste this prompt into Claude Code, Codex, or Cursor:```
Install Cargo by following https://api.getcargo.io/INSTALL.md
That URL serves a short install skill written for the agent to execute: it installs the latest @cargo-ai/cli from npm, signs you in with an emailed code (cargo-ai login --email, no browser, and it creates the account on first use), installs these skills on one channel for whichever agent it is, verifies with cargo-ai whoami, then starts on a real job. Read it first with curl -fsSL https://api.getcargo.io/INSTALL.md.
Manual — skills.sh```bash
npx skills add getcargohq/cargo-skills --all
`--all` is shorthand for `--skill '*' --agent '*' -y`: it takes every skill in the bundle and behaves the same in a terminal, in CI, and inside an agent. Drop it to pick interactively, or name one skill with `getcargohq/cargo-skills/`.
Works with Claude Code, Codex, Cursor, Windsurf, GitHub Copilot, Hermes Agent, and any agent that supports the skills.sh standard.
### Hermes Agent
Hermes reads the same `SKILL.md` standard, so all nineteen skills work there with no Cargo-side changes. Install them whichever way suits you:```bash
# From inside Hermes, via the skills.sh source
hermes skills install skills-sh/getcargohq/cargo-skills/cargo-gtm
# Or straight from GitHub, one skill at a time
hermes skills install getcargohq/cargo-skills/cargo-gtm
# Or the whole bundle from outside Hermes
npx skills add getcargohq/cargo-skills --agent hermes-agent
The last one writes all nineteen to .hermes/skills/ (or ~/.hermes/skills/ with -g). Cross-skill references resolve because the skills land as siblings — the same layout every other channel uses.
To subscribe to the whole repo as a tap, add it and then point it at the repo root, since these skills live at the top level rather than under skills/:```bash
hermes skills tap add getcargohq/cargo-skills
then set "path": "." for this entry in ~/.hermes/skills/.hub/taps.json
**Two things differ on Hermes.** The plugin channel below is Claude Code / Codex / Cursor / Grok only, so its approval hook doesn't apply — Hermes gates tool calls with its own approval policy, and its `pre_tool_call` hooks can only *block* a call, never pre-approve one. Expect `cargo-ai` commands to prompt. And with no bundled session-lifecycle hooks, the session's three jobs (refresh, register, finalize) are the agent's to run by hand — the router skill already accounts for agents without lifecycle hooks.
### Just one job — `gtm-skills`
If you want a single outcome rather than the whole workstation, `getcargohq/gtm-skills` packages the same jobs as standalone skills named after the job rather than after Cargo:```bash
npx skills add getcargohq/gtm-skills --all # all of them
npx skills add getcargohq/gtm-skills/find-work-email # or exactly one
Finding leads and stakeholders, building a TAM, resolving and enriching LinkedIn profiles, work emails and verification, company enrichment, job-change, funding and tech-intent signals, and migrating off a Clay table. The current list is in that repo's README; it is not repeated here, because a hand-maintained copy of somebody else's list is a copy that goes stale. Each installs alone, carries its own cost table, and runs end to end inside the 100 free credits.
Install those or this pack, not both — each standalone skill defers to cargo-gtm when the pack is present, so the same request is never claimed twice.
Agent plugin (alternative channel — Claude Code, Codex, Cursor, Grok)
The repo also installs as a native agent plugin: one source, four plugin formats across five hosts, sharing the same nineteen skills plus host-specific integration:
- An approval hook (
hooks/approve-cli.sh) that auto-approves safecargo-aicalls (reads, queries, run/batch operations) while credentials (login), token minting, report egress,project deploy/destroy, and anyremove/deletealways still prompt. Allow-only — it can never override a deny rule. Wired per plugin format:PreToolUse(Claude Code and Grok Build),PermissionRequest(Codex),beforeShellExecution(Cursor and Grok Bot). - A
SessionStarthook (Claude Code only) that keeps the CLI at the bundle's pinned version (npm install -g @cargo-ai/cli@, falling back to@latest) and refreshes the plugin for the next session (claude plugin marketplace update cargo-skills, thenclaude plugin update cargo@cargo-skills, in the background). It does not runskills add(the plugin owns the skills), and it reads nothing from the session and sends nothing anywhere — the plugin records no prompts, transcripts or summaries. - Native subagents (Claude Code and Grok Build):
cargo-execution-planner(costed GTM plans with pilot + budget reconciliation, read-only) andcargo-list-builder(parallel sourcing fan-out that executes only pre-approved slices). Grok Build loads the same Claude-compatible agent definitions through its plugin compatibility layer —agents/.
Optional extra — a statusline with live Cargo context (workspace · credits · CLI pin state). Statuslines are user-level config, so wire it yourself in ~/.claude/settings.json:```json
{ "statusLine": { "type": "command", "command": "node ~/.claude/plugins/marketplaces/cargo-skills/hooks/cargo-statusline.mjs" } }
(Adjust the path to wherever the plugin/marketplace is checked out. Renders from a small cache and never blocks — a detached child refreshes workspace/credits every ~2 minutes.)
**Claude Code** (≥ v2.1.154), typed by you inside Claude Code:```
/plugin marketplace add getcargohq/cargo-skills
/plugin install cargo@cargo-skills
An agent cannot type Claude Code's slash commands. When Claude Code installs Cargo for you, it runs the shell command instead, npx skills add getcargohq/cargo-skills --agent claude-code --global --yes, which installs the skills without the hooks. Add the plugin yourself afterwards if you want them, and remove the standalone copy when you do (see Pick one channel below).
Installed it as cargo@cargo? That copy is frozen: Claude Code reserves the marketplace name cargo and refuses to update or uninstall anything from it. Remove the marketplace (this also drops the plugin), then install under the new name:```
/plugin marketplace remove cargo
/plugin marketplace add getcargohq/cargo-skills
/plugin install cargo@cargo-skills
A project made from the Cargo template before 2026-10-22 also names the old id in `.claude/settings.json`: change `extraKnownMarketplaces.cargo` to `cargo-skills` and `"cargo@cargo"` to `"cargo@cargo-skills"`.
**Codex:**```bash
codex plugin marketplace add getcargohq/cargo-skills
# then install "cargo" from the Plugins menu
Cursor: open Customize in the sidebar → add the getcargohq/cargo-skills marketplace → install the Cargo plugin (UI-driven; the .cursor-plugin/ manifests are picked up automatically).
Grok Bot: open Connect apps → Team plugins → Cargo → Connect. Grok Bot currently consumes Cargo's Cursor-compatible plugin package. The plugin is account-level, while each Bot has its own cloud computer, so install the Cargo CLI on the Bot that will run Cargo and authenticate there. Browser OAuth is the recommended interactive path; the final whoami is the proof that the intended workspace is active.```bash
npm install -g @cargo-ai/cli
cargo-ai login --oauth
cargo-ai whoami
**Grok Build:** add the native Cargo marketplace and install its plugin. Grok plugins do not install runtime binaries, so install the Cargo CLI separately, then authenticate.```bash
grok plugin marketplace add getcargohq/cargo-skills
grok plugin install cargo --trust
grok plugin enable cargo
npm install -g @cargo-ai/cli
cargo-ai login --oauth
cargo-ai whoami
The native Grok Build package deliberately does not run the Claude-only session hooks, silently install software, transmit session data, or embed a Cargo token. To use Cargo's hosted MCP server instead of the CLI, follow the cargo-mcp skill and connect https://mcp.getcargo.io/mcp with OAuth or a workspace-scoped bearer token.
Claude Cowork (Claude Desktop): open Customize in the sidebar → + next to Personal plugins → Create plugin → Add marketplace → enter https://github.com/getcargohq/cargo-skills → install the Cargo plugin. Two sandbox-specific notes:
- Network egress: in the session's Settings → Capabilities, turn on network egress and allow at least
api.getcargo.ioandregistry.npmjs.org(or all domains) so the CLI can install and reach Cargo. - Sign-in: the Cowork sandbox has no TTY, so the browser sign-in flow can't complete there. Use the emailed code instead:
cargo-ai login --email you@company.comsends it and exits, andcargo-ai login --email you@company.com --codefinishes, with no browser at any point. Or mint a workspace API token at app.getcargo.io → Settings → API and have the agent runcargo-ai login --token. Start the session on a project folder — auth persists in that folder, so later Cowork sessions on the same folder reuse it.
Pick one channel. Plugin install and skills add both register the skills; using both duplicates them (plugin copies are namespaced cargo:). Claude Code users update via /plugin marketplace update cargo-skills + /plugin update cargo@cargo-skills; Grok Bot users reconnect Cargo after the team plugin is updated; Grok Build users run grok plugin marketplace update cargo-skills + grok plugin update cargo.
For OpenClaw, install the bundle from ClawHub:```bash
clawhub install getcargohq/cargo-skills # current workspace's skills/
clawhub install getcargohq/cargo-skills --global # ~/.openclaw/skills (shared)
Each skill ships a `metadata.openclaw.install` block that pulls `@cargo-ai/cli@latest` from npm and exposes the `cargo-ai` bin on first run, so no separate prerequisite step is needed.
## Staying current
The Cargo CLI and these skills ship updates regularly. The bundle pins the CLI version it was written against in `cargo/cli-version` — the CLI release pipeline PRs a bump here, and merging that PR is the deliberate "skills + CLI verified together" promotion. The session-start hook and the install docs read the pin and fall back to `latest` when it's unreadable, so the pin can never block an install.
### Claude Code
Install the **Cargo plugin** above
(`/plugin marketplace add getcargohq/cargo-skills`, then `/plugin install cargo@cargo-skills`) and the
bundled `SessionStart` hook keeps everything current automatically: every new Claude Code session
converges `@cargo-ai/cli` to the pin and refreshes the plugin itself for the next session. The hook
swallows errors, so a missing `npm`/`claude` binary never blocks a session.
If you would rather have the agent do the whole setup — install the CLI, sign you in, and install
the skills for whichever agent it is — paste this to Claude Code, Codex or Cursor:```
Install Cargo by following https://api.getcargo.io/INSTALL.md
That URL serves a short install skill the agent reads and executes itself. Nothing is written into
~/.claude on your behalf, and you can read the exact instructions first with
curl -fsSL https://api.getcargo.io/INSTALL.md.
Doing it by hand is three commands:```bash
npm install -g @cargo-ai/cli
cargo-ai login --email you@company.com # emailed code, no browser
cargo-ai whoami
> **The `curl … install.sh | sh` bootstrap is retired.** The old one-liner installed the CLI and
> scaffolded hooks; it now only prints a notice and exits non-zero, so a pinned copy fails loudly
> instead of appearing to succeed. Use the plugin, the `INSTALL.md` paste, or the three commands
> above. (Older installer versions scaffolded standalone `SessionStart`/`Stop`/`SessionEnd` hooks
> under `~/.claude/hooks/` that logged sessions to Cargo. Remove them and their entries in
> `~/.claude/settings.json`; the plugin does not need them.)
Without the plugin, the `cargo` router skill still instructs the agent to refresh CLI + skills at the start of every session (see `cargo/SKILL.md`) — that works out of the box, just without the hard enforcement the hook provides.
### OpenClaw
`metadata.openclaw.install` pins `@cargo-ai/cli@latest` so first install always fetches the latest CLI. To refresh an already-installed bundle:```bash
clawhub install getcargohq/cargo-skills # re-run to pull latest skills
npm install -g "@cargo-ai/cli@$(cat ~/.openclaw/skills/cargo/cli-version 2>/dev/null || echo latest)"
Grok Bot / Grok Build
For Grok Bot, updates arrive through the account's team-plugin catalog. Reconnect Cargo from Connect apps if the connected copy is stale. For Grok Build, refresh the marketplace and plugin explicitly. The CLI remains pinned separately by the bundle's cargo/cli-version file because agent plugins distribute instructions and hooks, not npm packages.```bash
grok plugin marketplace update cargo-skills
grok plugin update cargo
cargo-ai doctor
If `doctor` reports that the CLI is behind the skill bundle's pin, ask Grok to read `cargo/cli-version` from the installed plugin and install that exact `@cargo-ai/cli` version.
### Cursor / Windsurf / Copilot / other skills.sh agents
Re-run the install command — `skills add` clones the repo fresh each time, so the bundle is always current:```bash
npx skills add getcargohq/cargo-skills # refreshes skills (brings the pin with it)
npm install -g "@cargo-ai/cli@$(cat ~/.claude/skills/cargo/cli-version 2>/dev/null || echo latest)"
Publishing new versions to ClawHub
.github/workflows/clawhub-publish.yml publishes every skill whose version: was bumped, on each GitHub release. One-time setup:
- Sign in at clawhub.ai with the GitHub account that owns the
cargo-aiorg publisher (runclawhub publisher create cargo-aifirst if it doesn't exist), then generate an API token from the web UI. - Add it as a repo secret named
CLAWHUB_TOKEN.
Then bump the version: field in each changed SKILL.md (semver, e.g. 1.0.0 → 1.1.0) and cut a release. The workflow authenticates with clawhub login --token, calls clawhub skill publish ./ --version --owner cargo-ai for each skill, skips ones whose published version is unchanged, and fails on any other error. Trigger a manual run with workflow_dispatch (optional dry_run: true) to preview.
What this skill teaches
Cargo connects your data models (companies, contacts, deals) to external integrations (CRMs, enrichment providers, AI agents) and runs them as automated workflows. The repo ships nineteen skills at the root — one router skill (cargo, the overview / front door for any Cargo CLI task), one onboarding skill (cargo-quickstart, the guided first-run demo), one outcome skill (cargo-gtm, the front door for any GTM task), and sixteen capability skills (one per CLI domain, plus the cross-domain cargo-diagnostics and the hosted-MCP-server skill cargo-mcp). Most capability skills wrap the imperative CLI (one-off cargo-ai operations); cargo-project is the declarative one — define a whole workspace in code and deploy it — and cargo-diagnostics sequences the run/SQL/billing surfaces into forensic runbooks (trace a run, sweep a batch for errors, profile credit spend).
Router — cargo
Always-loadable overview. Explains the skill graph (router → outcome → capabilities), the UUID flow between skills, async polling, end-to-end use cases, and the most common gotchas. Bundles cargo/references/glossary.md for term-by-term definitions. Load first when starting any Cargo CLI task or when stitching multiple capability skills together.
Onboarding — cargo-quickstart
Guided first-run demo: one question ("who do you sell to?") → 25 leads matching that persona in under two minutes → cost receipt → save the pull as a recurring play. The fastest way to feel what Cargo is on a fresh workspace.
Outcome — cargo-gtm
Load when the user states a real-world goal. cargo-gtm is the meta-skill — it routes to phase guides, scenario recipes, and per-provider playbooks all bundled inside the same skill.
Built-in recipes:
| Recipe | Use when… |
|---|---|
source-planning.md |
Read first when the source isn't obvious. Probe candidate sources on 5–10 rows and cost them per hit before any fan-out. |
prospecting.md |
Find people matching a description, enrich, verify, sync. End-to-end flagship. |
build-tam.md |
Build a Total Addressable Market list at scale (100–10,000 companies). |
sales-navigator-extraction.md |
Extract a Sales Navigator search past the 1,000-account / 2,500-people cap: count, split, merge, load into models. |
find-stakeholders.md |
Find the buying committee at a named account by title, seniority and department. |
score-leads.md |
Score and tier a company list against the ICP, with the reason on every row. |
research-account.md |
Brief one account before a meeting, every line traced to a source. |
monitor-buying-signals.md |
Watch target accounts for dated, linked buying signals, free rung first. |
linkedin-url-lookup.md |
Resolve a person's LinkedIn URL from name + company with strict identity validation. |
portfolio-prospecting.md |
Find every company backed by a specific investor / accelerator, then prospect into them. |
job-change-monitoring.md |
Detect job changes in a contact segment (waterfall.detectJobChange — cargo-unique). |
funding-watch.md |
Track companies that recently raised funding for outbound timing. |
tech-intent.md |
Find companies by tech-stack or hiring intent (theirStack-driven). |
icp-discovery.md |
Diff Closed-Won vs Closed-Lost segments, surface differentiating ICP signals. |
custom-datapoints.md |
Design which custom attributes and live signals to collect for an ICP — each gated on a real catalog source, cost, and probed coverage. |
outreach-activation.md |
Turn a signal segment into send-ready outreach (enrich → verify → personalize → sequencer handoff). |
ads-audience-activation.md |
Push a segment to paid media — Google Ads Customer Match / LinkedIn Matched Audiences — and read the match rate. |
review-and-iterate.md |
Human review loop for judgment output: sheet handoff, grouped corrections, permanent fixes, kept as an eval set. |
re-engagement.md |
Wake up stale contacts only when a fresh signal fires (job change, funding, tech intent). |
lost-deal-revival.md |
Revive Closed-Lost CRM deals by branching on lost_reason (champion left, budget, timing). |
account-expansion.md |
Multi-thread existing customer accounts — net-new buyers, deduped against the Contacts model. |
save-as-play.md |
Convert a successful ad-hoc run into a durable scheduled play or cron tool. |
import-gtm-data.md |
Import existing GTM data (CSV/CRM exports) into models, QA-audit it, rebuild recurring logic as plays with a parity check. |
clay-to-cargo.md |
Migrate a Clay table specifically: extract the column configuration rather than the CSV, map every column family to its Cargo action, and prove parity against Clay's own output before switching. |
Capabilities
The standard library. Load when you need the syntax for a specific CLI domain — plus the three cross-cutting entries: Project (the declarative mode), Diagnostics (forensic runbooks over the other surfaces), and MCP (the hosted server, the one surface that is not the CLI).
| Domain | What the agent learns |
|---|---|
| Orchestration | Execute single actions, chain actions into workflows, trigger batches across segments, poll async operations, query orchestration runtime tables (runs/batches/spans/records) with SQL, fetch segment data |
| Storage | Inspect models and their DDL, create columns, navigate datasets, set relationships between models, query workspace storage with SQL |
| Segmentation | Build and manage segments — the saved filters that name the audience for a batch, a play trigger, or an export — size an audience before spending on it, and read the change (delta) feed |
| Connection | Authenticate connectors, discover integration actions and their slugs across 140+ integrations |
| AI | Create and configure agents, configure releases, attach knowledge for RAG, connect MCP servers, inspect agent memories |
| Content | Upload and organize knowledge files; build native and connector-backed knowledge libraries for RAG (the content domain) |
| Context | Browse, read, write, and edit the workspace's git-backed context repo (markdown/MDX GTM knowledge base); run shell commands in its runtime sandbox; inspect the knowledge graph |
| Analytics | Download run results and outputs, export segment data, monitor error rates and success metrics |
| Billing | Track credit consumption per workflow or connector, check subscription status, view invoices |
| Observability | Create and manage alerts — scheduled threshold checks on workflow telemetry (spans/runs/records), a model's health, or a SQL query — that fire actions (connector/tool/agent runs) on breach; preview, list, and inspect their firing history |
| Hosting | Scaffold, deploy, and promote hosted apps (Vite SPAs) and edge workers (serverless HTTP handlers), manage their deployments, and give workers env vars and secrets |
| Mailboxes | Provision sending inboxes Cargo owns on a sending domain, run provider warm-up and the 5→40/day send ramp, deliver with the sendEmail action (0.1 credits/send), and read back threads, replies, opens, clicks, and the workspace suppression list |
| Workspace | Invite users, create and rotate API tokens, organize resources into folders, manage roles |
| Project (declarative) | Declare an entire workspace in a project — the folder holding cargo.json (define* builders) — and deploy it with cargo-ai project (init → types → plan → deploy → destroy). Spans every resource type; use for GTM as Code / reproducible / version-controlled setups |
| Diagnostics (cross-domain) | Explain workflow behavior after the fact: trace why one run misbehaved, sweep a batch or play for errors grouped by root cause, profile where a play's credits go. Forensic runbooks over the run / orchestration-SQL / billing surfaces |
| MCP (not a CLI domain) | Drive Cargo from the hosted MCP server at https://mcp.getcargo.io/mcp with no CLI installed: connect a client over OAuth or a bearer token, discover and price an action with search_actions, execute it over one record or a batch, poll it, read models — and route between the MCP tools and the CLI |
What can I ask for?
Prompts that route through cargo-gtm:
- "Find me 5 fintech CTOs in NYC and verify their emails." →
recipes/prospecting.md - "Build a TAM list of seed-stage SaaS companies in Europe." →
recipes/build-tam.md - "Resolve the LinkedIn profile for John Smith at Acme Corp." →
recipes/linkedin-url-lookup.md - "Detect job changes among contacts in our customers segment." →
recipes/job-change-monitoring.md - "Find every company backed by Sequoia and prospect into the portfolio." →
recipes/portfolio-prospecting.md - "Show me everyone hiring data engineers AND running Snowflake." →
recipes/tech-intent.md - "What ICP signals differentiate our Closed-Won deals?" →
recipes/icp-discovery.md - "What custom data points should we be collecting on our accounts?" →
recipes/custom-datapoints.md
For ad-hoc CLI work (modify a model, list connectors, query storage, edit the GTM context repo), load the matching capability skill directly.
Use cases
Execute a single action
Ask your agent to run one action on a record — it will pick the right action kind (connector, tool, or agent), execute it, and return the result.
> "Enrich acme.com with waterfall."
> "Run the lead scorer on this contact."
Run an existing workflow
Ask your agent to trigger a play or tool — it will discover the workflowUuid, construct the right input, trigger the batch or run, and poll until completion.
> "Run the lead enrichment tool on Acme Inc."
> "Trigger the scoring play on our new MQL segment."
Build a workflow from scratch
The agent can construct a full node graph — fetching the connector UUID, looking up the action slug, validating the graph, and executing it — without you touching the UI.
> "Build and run a workflow that enriches company domains with waterfall and writes the result back to the Companies model."
Query storage with SQL
The agent fetches the DDL first (to get the exact table name), then writes and executes the SQL query.
> "How many companies in our model have employee_count above 500 and are headquartered in the US?"
Score or research records with an AI agent
The agent creates or finds a configured Cargo agent, sends a message, polls for the response, and surfaces the result.
> "Use the lead researcher agent to find the LinkedIn of every contact added this week."
Edit the workspace's GTM context
The agent browses, reads, and edits the git-backed context repo (personas, plays, proof, objections, etc.) via the runtime sandbox, and uses the knowledge graph to audit cross-references.
> "Add a persona file for Head of RevOps at mid-market SaaS."
> "Find every play that references the funding signal but has no proof attached."
Monitor workflow health
The agent pulls error counts and success metrics for a workflow and flags anything outside normal range.
> "Show me the error rate for the CRM sync play over the last 7 days."
Get alerted when something breaks
The agent creates a scheduled alert — an error-rate spike, a credit ceiling, a slow node, a stalled sync, or a workflow that stopped running — that fires a notification (or any action) on breach, without you having to look.
> "Alert me when the CRM sync's error rate goes above 10%, and page the on-call agent."
Export segment data
The agent downloads a filtered, sorted export of any model segment directly to a file.
> "Export all US companies with fewer than 200 employees, sorted by creation date."
Bootstrap a new workspace
The agent handles the full setup sequence: create models, add columns, set relationships, connect integrations, configure agents, and invite team members.
> "Set up a fresh Cargo workspace with Companies and Contacts models, a waterfall connector, and a GPT-4o scoring agent."
Track credit usage and costs
The agent queries billing metrics broken down by workflow, connector, or date range.
> "How many credits did the enrichment play consume last month?"
Prerequisites```bash
npm install -g @cargo-ai/cli
Recommended: emailed code, no browser. Creates the account on first use.
…(正文过长,页面只展示前面部分,完整内容见仓库)
```
