What makes cargo-orchestration notable?

2.2K downloads. Trust evidence available

How should cargo-orchestration be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

cargo-orchestration

Make Cargo actually run something, or show what it would run — execute one connector action, run a multi-step workflow, trigger a batch across a whole segment or model, message an AI agent, build or edit a node graph, draw a workflow, tool or play as a diagram, and query the runtime tables (runs, batches, spans, records) with SQL. Triggers: "run this on all my contacts", "execute the action", "kick off a batch", "build a workflow", "schedule a play", "make it run every morning", "ask the agent", "show me the workflow", "what does this tool do", "visualize this play", "draw the graph", "explain this workflow", "how many runs failed today", "what is the output schema for this action", "add a step that". Skip when: explaining why a run misbehaved — use cargo-diagnostics; downloading result files — use cargo-analytics; committing the workflow as code — use cargo-project.

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

2.2k

Updated

Oct 9, 2026

Version

1.13.0

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 2.2K downloads reported by the source. Last updated 10/9/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 9, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 9, 2026
Adoption signal: 2.2K downloadsadoption · observed Oct 9, 2026
Latest release: 1.13.0release · observed Sep 24, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s178dcd9wkfn0a2fqrygmt3jzn87j9e1:cargo-orchestration

Install using `clawhub skill install s178dcd9wkfn0a2fqrygmt3jzn87j9e1:cargo-orchestration` in an isolated environment before connecting it to live workloads.
No published capability contract is available yet, so validate auth and request/response behavior manually.
Review the upstream CLAWHUB listing at https://clawhub.ai/cargo-ai/cargo-orchestration before using production credentials.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-cargo-ai-cargo-orchestration/snapshot"

Documentation

CLAWHUB

156,605 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: cargo-orchestration
description: "Make Cargo actually run something, or show what it would run — execute one connector action, run a multi-step workflow, trigger a batch across a whole segment or model, message an AI agent, build or edit a node graph, draw a workflow, tool or play as a diagram, and query the runtime tables (runs, batches, spans, records) with SQL. Triggers: \"run this on all my contacts\", \"execute the action\", \"kick off a batch\", \"build a workflow\", \"schedule a play\", \"make it run every morning\", \"ask the agent\", \"show me the workflow\", \"what does this tool do\", \"visualize this play\", \"draw the graph\", \"explain this workflow\", \"how many runs failed today\", \"what is the output schema for this action\", \"add a step that\". Skip when: explaining why a run misbehaved — use cargo-diagnostics; downloading result files — use cargo-analytics; committing the workflow as code — use cargo-project."
version: "1.13.0"
compatibility: Requires @cargo-ai/cli (npm). Sign in or create an account with `cargo-ai login --email` (emailed code, no browser), `--oauth`, or an API token
homepage: https://github.com/getcargohq/cargo-skills
metadata:
  author: getcargo
  openclaw:
    requires:
      bins:
        - cargo-ai
    install:
      - kind: node
        package: "@cargo-ai/cli@latest"
        bins:
          - cargo-ai
    homepage: https://github.com/getcargohq/cargo-skills
---

# Cargo CLI — Orchestration

Runtime operations for the Cargo platform.

**What do you want to run?**

```
Need to run something?
├── Don't know the action yet    → action list <keywords>
├── One action, one record       → action execute
├── One action, many records     → action execute-batch
├── Multiple actions chained
│   ├── One-off / ad-hoc         → run create --nodes (one record)
│   │                              batch create --nodes (many records)
│   └── Reusable workflow        → build a tool, then run create --workflow-uuid
│                                  or batch create --workflow-uuid
├── Conversational AI agent      → message create
└── Testing ONE node of a
    workflow you're building     → node execute (debug only — see below)
```

> **Fanning out across many records (`action execute-batch`, `batch create`)? Sample first.** Run 10–20 records, report the observed cost and hit-rate, then ask the user to approve the full enrollment — quoting the **record count** and the **credit estimate**. See [Create a batch → the sample gate](#the-sample-gate).

> **Every node execution costs 0.01 credits — 1 credit per 100 — whatever the node is.**
> `branch`, `filter`, `switch`, `variables` and the rest carry no provider price, but
> they are not free: the charge is per *execution*, so a graph's cost has two terms,
> `(provider cost × records) + (nodes × records ÷ 100)`. On step-heavy, action-light
> graphs the second term dominates. It shows up in **no** per-node field — not
> `executions[].creditsUsedCount`, not `spans.executi

_meta.json

{
  "ownerId": "kn7by8t6yt9yghbxtxz6hv0bts87k6bq",
  "slug": "cargo-orchestration",
  "version": "1.13.0",
  "publishedAt": 1790278699916
}

references/examples/actions.md

# Action examples

## What is an action?

An **action** is a single operation you can execute without building a workflow. Use `action execute` for one record, or `action execute-batch` for multiple records.

Actions come in four kinds:

| Kind        | What it does                         | Required fields                                |
| ----------- | ------------------------------------ | ---------------------------------------------- |
| `tool`      | Run an orchestration tool            | `toolUuid` or `templateSlug` or `releaseUuid`  |
| `connector` | Call a third-party service           | `integrationSlug` + `actionSlug`               |
| `agent`     | Invoke an AI agent                   | `agentUuid` or `templateSlug` or `releaseUuid` |
| `native`    | Run a built-in platform action       | `actionSlug`                                   |

`config` is where a **node** keeps its configuration; a top-level action has none — its inputs go in `--data` (single) or `--records` (batch). Omit the key on `execute` / `execute-batch`: that is the shape `action list` returns, and `"config": {}` is merely tolerated there.

`get-output-schema` takes the same pair — the action, plus `--data` when the output depends on the inputs (a HubSpot object type, a target sheet). Nodes, alert `--actions`, play `healthAlertActions`, and agent / MCP-server `--actions` are where `config` still belongs: it is a node's configuration, never an action's input.

> **When to use actions vs workflows:** Actions are for running a **single operation** without building a workflow graph. If you need to **chain multiple operations** together (enrichment → scoring → CRM push), use `run create --nodes` or `batch create --nodes` instead. See `tools.md` for workflow examples.

---

## Find an action — `action list`

Free: no run, no credits. Searches the integration catalog, Cargo native actions, this workspace's tools, and its agents in one call.

```bash
cargo-ai orchestration action list enrich company
cargo-ai orchestration action list --kind tool
cargo-ai orchestration action list send --kind connector --integration-slug slack
cargo-ai orchestration action list verify email --limit 5
```

| Flag | Meaning |
| --- | --- |
| `[query...]` | Space-separated keywords. **All** terms must match (AND), against action slug, name, description, and integration. Omit to browse. |
| `--kind` | One of `connector`, `native`, `tool`, `agent`. `tool` and `agent` need a signed-in workspace. |
| `--integration-slug` | Restrict connector results to one integration. |
| `--limit` | Default 20, max 50. |

Response:

```json
{
  "query": "enrich company",
  "totalMatches": 37,
  "results": [
    {
      "name": "Enrich company",
      "description": "Return firmographics for a domain…",
      "score": 12,
      "action": {
        "kind": "connector",
        "integrationSlug": "aiArk",
        "actionSlug": "enrichCompany",
        "connectorUuid": "<uuid>"
      },
      "connectors": [{ "uuid":

references/examples/agents.md

# AI agent examples

## Basic chat: ask a question and get a response

```bash
# 1. Find the right agent by name
cargo-ai ai agent list
# → Match by name, extract agent uuid

# 2. Create a chat session
cargo-ai ai chat create \
  --trigger '{"type":"draft"}' \
  --agent-uuid <agent-uuid> \
  --name "Quick question"
# → Extract chat.uuid

# 3. Send a message
cargo-ai ai message create \
  --chat-uuid <chat-uuid> \
  --parts '[{"type":"text","text":"What is Acme Corp'\''s employee count?"}]'
```

Message create response:

```json
{
  "userMessage": { "uuid": "user-msg-uuid", "status": "success" },
  "assistantMessage": {
    "uuid": "assistant-msg-uuid",
    "status": "pending",
    "parts": []
  }
}
```

```bash
# 4. Poll for the response (repeat every 2s)
cargo-ai ai message get <assistant-msg-uuid>
```

Poll until `status` is `success` or `error`:

```json
{
  "message": {
    "uuid": "assistant-msg-uuid",
    "status": "success",
    "parts": [
      { "type": "text", "text": "Acme Corp has approximately 500 employees..." }
    ],
    "errorMessage": null
  }
}
```

Status values: `pending` → `generating` → `success` or `error`. On `error`, read `.message.errorMessage`.

## Multi-turn conversation

```bash
# 1. Create a chat
cargo-ai ai chat create \
  --trigger '{"type":"draft"}' \
  --agent-uuid <agent-uuid> \
  --name "Lead research"
# → Extract chat.uuid

# 2. First message
cargo-ai ai message create \
  --chat-uuid <chat-uuid> \
  --parts '[{"type":"text","text":"Find the VP of Sales at Acme Corp"}]'
# → Poll assistantMessage.uuid until success

# 3. Follow-up in the same chat (agent remembers context)
cargo-ai ai message create \
  --chat-uuid <chat-uuid> \
  --parts '[{"type":"text","text":"Now find their email address"}]'
# → Poll the new assistantMessage.uuid

# 4. Another follow-up
cargo-ai ai message create \
  --chat-uuid <chat-uuid> \
  --parts '[{"type":"text","text":"Draft a cold outreach email to them"}]'
# → Poll again
```

## Reuse an existing chat session

```bash
# 1. List existing chats for an agent
cargo-ai ai chat list --agent-uuid <agent-uuid> --limit 10
# → Find a chat by name or pick the most recent one

# 2. Send a message in the existing chat
cargo-ai ai message create \
  --chat-uuid <existing-chat-uuid> \
  --parts '[{"type":"text","text":"Any updates on the Acme deal?"}]'
# → Poll for response
```

## Send a message with actions

Give the agent access to specific actions for enrichment, CRM actions, etc.

```bash
cargo-ai ai message create \
  --chat-uuid <chat-uuid> \
  --parts '[{"type":"text","text":"Enrich this lead and add to Salesforce"}]' \
  --actions '[{"slug":"clearbit","kind":"tool","toolUuid": "<tool-uuid>","config":{}},{"slug":"salesforce","kind":"tool","config":{}}]'
# → The agent can use these actions during its response
```

## Send a message with model resources

Give the agent access to a data model to query.

```bash
# 1. Find the model UUID
cargo-ai storage model list

# 2. Send message with th

references/examples/plays.md

# Play examples

## What is a play?

A **play** is a segment-driven automation. It is linked to a specific model and segment, and runs its workflow automatically when records in that segment change (are added, updated, or removed). Plays are the reactive side of Cargo — "when this data changes, do that."

Key properties of a play:

- **`name`** — human-readable name (workflows themselves don't have names)
- **`workflowUuid`** — the underlying workflow that executes
- **`modelUuid`** — the data model the play operates on
- **`segmentUuid`** — the segment that triggers runs
- **`changeKinds`** — which segment changes trigger a run (`added`, `updated`, `removed`)
- **`schedule`** — optional cron schedule for periodic re-evaluation
- **`isEnabled`** — whether the play is active

## List all plays

```bash
cargo-ai orchestration play list
```

Response:

```json
{
  "plays": [
    {
      "uuid": "play-uuid",
      "name": "Enrich new companies",
      "workflowUuid": "workflow-uuid",
      "modelUuid": "model-uuid",
      "segmentUuid": "segment-uuid",
      "changeKinds": ["added", "updated"],
      "isEnabled": true,
      "schedule": null,
      "description": "Enriches companies when they enter the segment"
    }
  ]
}
```

## Find a play's workflow UUID

Plays have names — workflows don't. Use the play to find the right workflow and model.

```bash
# 1. Find the play
cargo-ai orchestration play list
# → Extract play.workflowUuid and play.modelUuid

# 2. Create a batch over the play's model (empty filter = all rows)
cargo-ai orchestration batch create \
  --workflow-uuid <play.workflowUuid> \
  --data '{"kind":"filter","modelUuid":"<play.modelUuid>","filter":{"conjonction":"and","groups":[]}}'

# 3. Poll until done
cargo-ai orchestration batch get <batch-uuid>

# Or block until finished — returns the final batch result without a separate poll step
cargo-ai orchestration batch create \
  --workflow-uuid <play.workflowUuid> \
  --data '{"kind":"filter","modelUuid":"<play.modelUuid>","filter":{"conjonction":"and","groups":[]}}' \
  --wait-until-finished
```

An empty filter (`{"conjonction":"and","groups":[]}`) enrols every row in the model;
add conditions to narrow it — see `references/filter-syntax.md` for the full shape.

> **Never pass `play.segmentUuid` to `{"kind":"segment"}`.** That UUID points at
> the play's internally generated segment, whose record count is never
> populated — the batch is rejected (`segmentLinkedToPlay`, or `noRecords` on
> older backends) no matter how many rows the model holds. `{"kind":"segment"}`
> is only for standalone segments from `segmentation segment list`.

## Update a play's workflow

To change what a play does, update its draft release and deploy it. The draft release holds the unpublished node graph for the workflow.

> **Looking for inspiration?** Before designing a node graph from scratch, check `cargo-ai orchestration template list` for pre-built patterns (lead scoring, enrichment pipelines, CRM syncs).

Github ReposUpdated 2h agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.