Audienti CLI

Audienti CLI is the agent-first command-line client for the Audienti production API and the local bridge for Audienti's app-hosted MCP endpoint. It lets local coding agents and operators inspect accounts, create and manage plays, import prospects, build lists, manage task reminders, configure list routing rules and account-user automation safety, and work supported operator flows.

The Motion Approach guides post-accept planning and writing. Set it with audienti motions update motn_123 --approach "Test the premise before asking for a meeting" or the approach field in a create/update payload. A nonblank Approach automatically chooses adaptive planning; blank, nil, or whitespace uses the existing sequence. --approach "" explicitly clears it and restores the existing sequence. There is no separate planning-mode selector. Existing sending controls still apply.

audienti operator queue and operator next show planner and writer questions with candidate options. Answer one with audienti operator answer <row_id> --choice <id> or --answer "Your guidance". The command fetches that exact row even when it is not the next move, then submits its current fingerprints. Stale or double answers return 409; an accepted answer returns 202 planning. Answers guide only the current decision. Planning and preview never authorize sending.

Install

Requires Node.js 20 or newer.

curl -fsSL https://cli.audienti.com/install | bash

At a terminal, the installer runs audienti start for you. Or install directly through npm, then start:

npm install --global @audienti/cli
audienti start

For one-off use, run npx @audienti/cli --help.

First run

audienti start
audienti setup

audienti start walks you through the same path as the web:

1. It prints the intro: what Audienti does and how it warms people up.
2. It opens Audienti in your browser so you can sign in or create an account, then picks your account and account user (automatically when there is only one).
3. If the account has not paid, it shows the price and credits. Press Enter to pay by card on the pay page (it opens in your browser and the address is printed; the terminal waits until the payment shows), or type a signup code.
4. It runs setup in the terminal from the step you are on. Step 1, your company: website, who you sell to, what they should say yes to, and your city, state or province, and country when the account needs them. Step 2, verify your targeting: the audience, offer and signals cards. Type a, o or s to change one card, or press Enter to create the experiment.
5. Step 3, go live: connecting LinkedIn is not in the terminal yet. The command prints the web page where you finish it.

audienti setup runs steps 1 and 2 on their own. Nothing is sent without your approval.

Without a terminal, audienti start never prompts and reports what to do next (payment_required with the pay page when the account has not paid), and setup takes flags:

audienti setup --url https://acme.com --sell-to "<who you sell to>" --ask "<what they say yes to>" --yes --json

Add --city <city> --state <code> --country <code> when setup says it needs your place.

Without --yes, a non-interactive setup drafts but creates nothing. Running audienti with no saved login starts audienti start; audienti --help still prints help.

Authenticate

Authenticate through the browser, then configure the default account context:

audienti auth login
audienti accounts list --json
audienti accounts create --name Doppel --parent OMALab --json
audienti accounts select <acct_id>
audienti users list
audienti users select <account_user_id|email|name|me>

audienti auth login opens Audienti in your browser, creates an API token from your signed-in web session, sends it back to a temporary 127.0.0.1 callback, and stores it in the local CLI config after validating it.

If you already have a token, you can still configure it directly:

audienti auth token <token>

The CLI writes its local configuration to ~/.config/audienti/config.json with owner-only permissions. Do not place a production token in an agent prompt, repository file, issue, or CI secret.

The selected account user is used when commands accept me or default to the current operator, such as audienti users activity, audienti analytics users, and audienti prospects assign --assigned-user me.

Agent Workflows

Before creating, changing or judging an experiment, read the strategy:

audienti help methodology

The guide explains premises, signals, informants, validating and gifting, cadence, mature-cohort verdicts, and accepted opportunities. Motion mutations print a short reminder to stderr; --json stdout remains machine-readable. experiments, experiment and plays are aliases for motions, including help.

For gift research that stays outside the Audienti app:

audienti tools gift-research --url https://example.com
audienti tools gift-research --url https://example.com --json

This prints a research skill and the website for the agent to investigate with its own browsing tools. It does not crawl the site, require login, scan through Audienti, save gifts or send outreach. The agent returns evidence-linked existing assets and clearly marked adaptations that someone would still need to build.

Discover the bundled skills and the Audienti marketplace snapshot:

audienti skills list
audienti skills show audienti-gift-research
audienti skills show signal-prospect-research

Bundled skills print their instructions. Marketplace entries print source links and host-specific install commands; the CLI does not install or execute them. Upstream repositories own those skills, dependencies and updates. The snapshot's source commit is included in skills list --json; check the upstream catalog for later additions.

The selected marketplace entries are the six social-network finders, signal-prospect-research, and sales-sheet-builder. Before using a social finder, agents must check their local browser/search tools, connectors, skills, CLIs and network access. skills show <finder> includes that environment check before the upstream instructions; JSON discovery includes it too. Missing access must be reported rather than assumed.

Start with the built-in, production-safe workflow guide:

audienti help agent-workflows

Use --json whenever another program or agent will consume the result. Inspect the target state before mutations, and use the command-specific help before creating, changing, or deleting data.

MCP

Audienti serves MCP from the app at /mcp. The package ships a small stdio bridge for MCP hosts that need a local command:

audienti-mcp

Use it this way:

1. Install the package.
2. Run audienti auth login.
3. Run audienti accounts select <acct_id>.
4. Configure your MCP host with the packaged .mcp.json, or point it at the audienti-mcp command.
5. In the MCP host, list tools and call the account-scoped tool you need.

The bridge reads the same ~/.config/audienti/config.json as the CLI, forwards MCP JSON-RPC messages to the app, and injects the selected account when a tool call does not include account_id. If you want a tool to run against a different account, pass account_id in that tool call.

MCP clients that can call HTTP directly may use the hosted endpoint instead of the stdio bridge:

curl https://app.audienti.com/mcp \
  -H "Authorization: Bearer $AUDIENTI_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'

Example tool call:

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "analytics.stages",
    "arguments": {
      "account_id": "acct_...",
      "query": {
        "interval": "weekly",
        "cohort_start_date": "2026-07-01",
        "cohort_end_date": "2026-07-31"
      }
    }
  }
}

Useful MCP tools to start with:

• auth.me confirms the token identity.
• accounts.list shows accessible accounts.
• setup.play_preflight returns LinkedIn connected-account readiness and setup or mapping URLs.
• offers.create, icps.create, and motions.create set up the offer, ICP, and play.
• analytics.stages returns stage conversion cohorts and stage aging.
• analytics.cohort_lists.create materializes event cohorts as reusable lists.

Common inspection commands:

audienti update check
audienti operator next --plan
audienti writer test-run <prsp_id>
audienti analytics motions --json
audienti analytics icps --json
audienti motions analytics <motn_id>
audienti motions run-discovery <motn_id>
audienti motions runs <motn_id> [--cursor <id>] [--limit <1-10>] [--json]
audienti motions quick-start --url https://example.com --wait --confirm
audienti motions abm-companies <motn_id> add --file abm-domains.txt
audienti motions abm-companies <motn_id> list
audienti motions update <motn_id> --status closing
audienti motions update <motn_id> --status paused
audienti motions update <motn_id> --start-date 2026-09-01 --end-date 2026-09-30 --maximum-company-count 25
audienti motions update <motn_id> --own-post-engagement true
audienti motions update <motn_id> --payload motion-principal-list.json
audienti motions update <motn_id> --payload motion-signals.json
audienti motions activate <motn_id>
audienti motions delete <motn_id> --confirm yes
audienti content programs
audienti content track <linkedin_post_url>
audienti content posts
audienti content engagement <cpwi_id> --json
audienti content plan <cprg_id>
audienti content plans --user me
audienti content plan <rprt_id> --report --user me
audienti content plan-update <rprt_id> --day 1 --payload edits.json
audienti content plan-approve <rprt_id> --day 1
audienti content plan-research <rprt_id> --day 1
audienti content plan-draft <rprt_id> --day 1 --feedback "Revise the opening"
audienti content plan-visuals <rprt_id> --day 1 --style <id>
audienti content post-reply <cpwi_id> --comment <task_id> --body "Approved reply"
audienti content approve <cpwi_id>
audienti content comments
audienti social-cookies sync-messages <scok_id> [--folder <folder>] [--retry] --json
audienti prospects show <prsp_id> --json
audienti prospects list --profiles
audienti prospects list --assigned-user unassigned
audienti prospects check --all --csv
audienti prospects assign <prsp_id> --assigned-user me
audienti prospects set-status <prsp_id> --status not_fit
audienti prospects lock <prsp_id> --note "Emergency hold"
audienti tasks list
audienti tasks add --title "Review Cristina" --due 2026-07-24T11:00 --prospect <prsp_id> --notes "Check the renewal note before replying."
audienti tasks complete <ptsk_id>
audienti dnc list
audienti company-rules list
audienti lists routing-rules <list_id> list
audienti lists routing-rules <list_id> apply
audienti users activity --window 7d
audienti users automation show 136 --platform linkedin --json --account <acct_id>
audienti users automation update 136 --payload automation-controls.json --json --account <acct_id>
audienti users automation update 136 --payload automation-controls.json --apply --json --account <acct_id>
audienti analytics prospects --window 24h
audienti analytics dashboard --play-tag wine_campaign
audienti analytics metrics --cohort-preset week-to-date
audienti analytics cohorts create-list --name "Blank note test" --start 2026-07-20 --end 2026-07-20 --note-mode blank
audienti analytics users --user me --window 30d
audienti analytics visibility --window 24h --user me
audienti analytics content --window week
audienti tools list
audienti tools humanize --file draft.txt --tone professional --language English
audienti tools linkedin-review --url https://www.linkedin.com/in/example --icp <icp_id>
audienti tools linkedin-review reports
audienti tools linkedin-review show <rprt_id>
audienti tools linkedin-review status <rprt_id>

To humanize arbitrary text without exposing the underlying provider key, pass a UTF-8 file. Plain output contains only the transformed text, so it can be redirected directly to another file:

audienti tools humanize --file draft.txt --tone professional > revised.txt
audienti tools humanize --file draft.txt --language English --json

Standalone account tools

These run without creating prospects or experiments. Each command returns a run id at once and keeps working on the server; --wait polls until the run finishes and prints the results. If the CLI exits, read the run later with tools runs show|results. Details expire after 90 days; the summary stays.

audienti tools email-find --first-name Ada --last-name Lovelace --company-domain example.com --wait
audienti tools email-find --file people.csv --request-key batch-2026-10-03   # csv, jsonl or json
audienti tools linkedin-enrich --url https://www.linkedin.com/in/example --wait --json
audienti tools signals-find --icp "Mid-size US logistics companies" --question "Who announced warehouse automation?" --count 5
audienti tools write --purpose "Book a call" --audience "Finance leads" --fact "Approvals take 2 days" --channel email
audienti tools humanize --file draft.txt --async --wait
audienti tools runs list --tool email-find
audienti tools runs results <trun_id> --json
audienti tools runs export <trun_id> --format csv --output results.csv

--file takes JSON (an array or {"items": [...]}), JSONL, or CSV with a header row. CSV is one row per line; quoted commas are allowed, line breaks inside fields are not. With --wait, the exit code is 1 on an API error, a timeout or an aborted (failed) run; per-item outcomes such as no_match do not change it.

Prefer tools email-find for an email lookup. tools get email still runs the prospect import pipeline and creates a prospect.

Saved network

Your own connected account's saved connections and following, from what normal work has already seen. Only the account's owner can read it, and it never visits LinkedIn or X. Coverage says partial, not yet observed, or capture not supported yet; none of these mean zero.

audienti network list --cookie <scok_id> --kind connection --query acme
audienti network list --cookie <scok_id> --kind follow --direction outgoing --json
audienti network export --cookie <scok_id> --kind connection --format csv --output connections.csv

To let an agent or operator check whether the local CLI is behind the latest published package:

audienti update check --json

To work the supported prospect operator queue from the CLI, inspect the next move and record the outcome against that same row:

audienti operator next --plan
audienti operator next --done --note "Connection request sent."

operator queue, operator failed-drafts, network-ops queue, and inbox-ops queue print a continuation command when more rows remain. Read-only operator next (including --plan) also prints one when its page has no focal move but more rows remain; when a move is present, inspect or act on it and rerun operator next. Follow the continuation command even when the current page has no ready rows. It preserves the account and filters and uses the API's exact --page and --offset (which can be zero), or its opaque --cursor. Do not combine a cursor with an offset. If the scan limit is reached, narrow the filters; an incomplete scan does not mean the queue is empty. JSON output preserves the API response. Pagination flags are not accepted when recording outcomes or requeueing drafts.

Network Ops has its own owner-scoped CLI surface for pending inbound LinkedIn connection requests. It shows the already-synced LinkedIn profile headline when one is present, keeps the exact invitation-bound message when one was captured, and queues the same canonical provider actions as the product UI:

audienti network-ops queue [--page <n>] [--offset <n>|--cursor <token>]
audienti network-ops accept <row_id>
audienti network-ops decline <row_id>

reject is accepted as an alias for decline. An accepted API response means the provider action was queued; it is not confirmation that LinkedIn completed the action. The same queue can be read with audienti operator queue --opportunity-kind network.

Inbox Ops has its own owner-scoped CLI surface built for clearing a backlog in bulk. inbox-ops queue follows every page, numbers each row, and saves the numbered list locally for the selected account. The bulk verbs select rows by number, range, row id, --domain, or --sender, print a manifest, and apply only with --yes (or an interactive confirmation). --dry-run validates every row on the server and reports planned, skipped, and rejected rows without changing anything:

audienti inbox-ops queue
audienti inbox-ops queue --group-by domain
audienti inbox-ops ignore 1-25 --dry-run
audienti inbox-ops ignore 1-25 --yes
audienti inbox-ops filter-domain 3,7 --yes
audienti inbox-ops filter-domain --domain alerts.example.com --yes
audienti inbox-ops filter-sender 12 --yes
audienti inbox-ops allow-sender 4 --yes
audienti inbox-ops allow-domain --domain customer.example --yes
audienti inbox-ops filters
audienti inbox-ops rule <row_id> --scope sender --disposition filter
audienti inbox-ops rule set --scope sender --key [email protected] --disposition filter
audienti inbox-ops rule remove --scope domain --key example.com

Numbers stay valid until inbox-ops queue runs again. ignore hides one thread until a newer reply arrives; filter-* and allow-* write durable rules that apply to every current and future matching message across the owner's accounts. Rule verbs given only --domain or --sender write the keyed rule directly, even when the matching rows are no longer listed. Every row is authorized individually on the server: rows another owner controls, stale rows, and malformed ids are rejected one by one while the rest still apply. Pass --page, --offset, or --cursor to read exactly one page instead.

All Inbox Ops commands update only the authenticated owner's personal/global Inbox Ops preferences or private ignore receipts. They do not archive mail, call the provider, or add a DNC entry.

To manage simple reminders for yourself:

audienti tasks list
audienti tasks list --status completed
audienti tasks add --title "Review target account" --due 2026-07-24T11:00 --list <list_id> --notes "Check the latest notes."
audienti tasks complete <ptsk_id>

To manage the same ordered rules shown in a list's Routing Rules UI, use a JSON payload for create and update operations:

audienti lists routing-rules <list_id> list
audienti lists routing-rules <list_id> create --payload routing-rule.json
audienti lists routing-rules <list_id> update <rule_id> --payload routing-rule.json
audienti lists routing-rules <list_id> move <rule_id> up
audienti lists routing-rules <list_id> remove <rule_id>
audienti lists routing-rules <list_id> apply

{
  "name": "VP prospects to Alice",
  "enabled": true,
  "action_kind": "assign_user",
  "target_account_user_id": "[email protected]",
  "conditions": {
    "seniorities": [
      {"id": "5", "name": "Vice President", "negative": false}
    ],
    "seniority_match_mode": "at_least"
  }
}

Use action_kind: "route_to_list" with target_list_id to route to another working list. apply queues the existing list-routing background job, just like the UI; it reports that work was enqueued, not that every prospect has finished routing. Location and company_location labels must resolve to a known geography at save time; unknown labels return 422. Run audienti lists routing-rules help for the full condition contract.

To inspect activity for prospects that entered the account during a specific cohort while keeping a separate activity window:

audienti analytics prospects --cohort-start 2026-07-01 --cohort-end 2026-07-07 --window 7d

To compare recent weekly prospect cohorts by their current pipeline stages:

audienti analytics prospects cohort-analysis --weeks 4 --motion <motn_id>

To inspect the current outcomes of outbound operations created in a date range, use the account-scoped metrics report:

audienti analytics metrics --cohort-start 2026-08-24 --cohort-end 2026-08-30 --interval daily
audienti analytics metrics --cohort-start 2026-08-24 --cohort-end 2026-08-30 --interval weekly
audienti analytics metrics --cohort-preset week-to-date --user me --motion <motn_id> --play-tag <tag> --list <list_id> --offer <offr_id> --icp <icp_id> --social-cookie <scok_id> --platform linkedin --action messaging.message_sent --outcome succeeded_after_retry
audienti analytics metrics --cohort-preset week-to-date --json

This is an events.created_at root-operation cohort, and each operation is classified by its current outcome across all of its attempts. It is distinct from the AccountProspect.created_at entry cohorts used by dashboard, stages, and prospect cohort analysis. The command makes one authenticated request to the account Metrics API. Plain text formats only the returned cohort ranges, Operations, First-try success, Recovered, Final failures, In progress, Attempts, selected daily or weekly grid rows, action rows, and account-wide Social Cookie rows. --json prints the API response deeply unchanged; the CLI does not recalculate cohorts, outcomes, counts, or rates.

The six leaf outcomes are first_attempt_success, succeeded_after_retry, failed_without_retry, failed_after_retry, in_progress, and unresolved. The success and failure values are umbrella filters over their corresponding two terminal leaf outcomes.

For example, the human output uses the server-provided values directly:

Outbound metrics
Cohort: 2026-08-24 to 2026-08-30 (events.created_at)
Current: 2026-08-24T00:00:00-05:00 to 2026-08-31T00:00:00-05:00
Previous: 2026-08-17T00:00:00-05:00 to 2026-08-24T00:00:00-05:00
Operations: 1347
First-try success: 1275 (94.7%)
Recovered: 40 (3%)
Final failures: 16 (1.2%)
In progress: 16 (1.2%)
Attempts: 1400

To materialize a connection-request activity cohort as a reusable list selector, then reuse it in analytics:

audienti analytics cohorts create-list --name "Connection requests 2026-07-01 to 2026-07-07" --event connection_request_sent --start 2026-07-01 --end 2026-07-07
audienti analytics dashboard --list <list_id>
audienti analytics prospects --list <list_id> --window 30d
audienti analytics users --user me --list <list_id> --start 2026-07-01 --end 2026-07-31

For prospect, dashboard, and stages analytics, use --cohort-start and --cohort-end when the cohort is based on when people entered Audienti, a motion, or a receiving segment. Use analytics cohorts create-list followed by --list when the cohort is based on an event that happened later, such as connection requests sent in a date range. Rebuild the list when the event definition or date window changes so the analytics question stays auditable.

audienti setup play preflight includes the selected sender's server-derived working schedule under social_cookie.automation, including active_days, normalized working_hours, effective time_zone, and current in_working_hours state. The human-readable output reports the same timezone, today's window, and whether provider execution is currently inside the window. It also reports the configured user fallback location, the connected account's configured and last-verified effective proxy geography, and the proxy source without exposing proxy URLs, credentials, egress IPs, or browser session data. For authorized LinkedIn account owners and admins, social_cookie.capabilities.linkedin reports Audienti's stored premium and sales_navigator booleans plus the checked_at timestamp. Text output shows yes, no, or unknown and when detection last ran. Null or missing values mean unknown, including older server responses and unavailable access. These are stored observations that may be stale; preflight does not perform a fresh provider check. --json preserves the server payload unchanged. For LinkedIn, social_cookie.automation.pacing includes effective weekly quotas, daily targets, motion active days, the outstanding-invitation cap, ramp configuration, current outstanding inventory, any inventory blocker, and current invitation capacity calculated by the server. A null weekly quota means unlimited.

For an email social cookie, social-cookies sync-messages requests the shared account-scoped cookie/folder sync slot and prints the server's durable status. Pass --folder to select a provider folder and --retry only when an explicit retry is intended. The command does not call a provider directly; --json returns the accepted request and sync_states payload unchanged.

Use users automation to inspect or change one account user's LinkedIn safety policy without changing the saved account selection:

audienti users automation show 136 --platform linkedin --json --account acct_example
audienti users automation update 136 --payload automation-controls.json --json --account acct_example
audienti users automation update 136 --payload automation-controls.json --apply --json --account acct_example

update is preview-only unless --apply is present. The CLI always sends platform: "linkedin" and an explicit apply boolean after the file fields, so a payload file cannot silently opt into applying a change. The server scopes the connected account through the selected account plus account user, preserves omitted controls, returns the before and proposed/actual after states, and records an audit event only for an applied update. --json prints the server payload unchanged.

Follow (including unfollow) and invitation withdrawal are enabled by default. Set follow_autopilot_enabled or withdraw_connection_autopilot_enabled to false to disable that action. These preferences still respect automatic sending and other execution limits; follows also require visibility automation.

An automation-controls.json warm-up payload can use every automation gate, independent action limits, an aggregate visibility limit, and a weekly ramp:

{
  "automation_controls": {
    "automatic_sending_enabled": false,
    "visibility_operations_autopilot_enabled": true,
    "follow_autopilot_enabled": true,
    "withdraw_connection_autopilot_enabled": true,
    "post_comment_autopilot_enabled": false,
    "connection_request_autopilot_enabled": false,
    "inmail_autopilot_enabled": false,
    "direct_message_autopilot_enabled": false,
    "email_sending_autopilot_enabled": false,
    "manual_action_handoff_enabled": false,
    "risk_cooldown_enabled": true
  },
  "action_limits": {
    "profile_view": { "hourly": 2, "daily": 4, "weekly": 20 },
    "follow": { "hourly": 2, "daily": 3, "weekly": 15 },
    "like": { "hourly": 1, "daily": 2, "weekly": 10 },
    "invite": { "hourly": 1, "daily": 2, "weekly": 10 },
    "message": { "hourly": 1, "daily": 2, "weekly": 10 },
    "comment": { "hourly": 1, "daily": 1, "weekly": 5 },
    "visibility": { "hourly": 3, "daily": 8, "weekly": 40 }
  },
  "visibility_ramp": {
    "enabled": true,
    "starting_daily_limit": 8,
    "weekly_increment": 2
  }
}

follow covers follows and unfollows; like covers likes and unlikes; message covers messages and InMail. visibility is the aggregate cap across profile views, follows/unfollows, and likes/unlikes. The show/preview readback includes configured, default, effective, used, and remaining hourly, daily, and weekly values plus the currently binding limits.

Motion update payload mode can replace the selected principal and backing list:

{
  "principal_account_user_id": 136,
  "list_id": "list_abc123"
}

The principal and list are resolved inside the selected account. Use "list_id": null to clear the backing list.

To inspect the account's current prospect mix by motion type and compare it with the rolling seven-day recorded-source contribution:

audienti analytics motions
audienti analytics motions --json

Current Unattributed counts mean no current motion association. Rolling seven-day Unattributed counts mean no attributable recorded source motion; the server falls back to the current motion only when recorded source data is blank.

To inspect the account's current prospect mix by source ICP and compare it with the rolling seven-day source contribution:

audienti analytics icps
audienti analytics icps --json

Unattributed means no attributable account source ICP. The server falls back to the current motion ICP only when recorded ICP source data is blank.

To see whether one motion is producing prospects by day, and where each produced-day cohort currently sits in the funnel:

audienti motions analytics <motn_id>

To count the people and distinct companies currently targeted by one campaign tag without waiting on the web dashboard filter:

audienti analytics dashboard --play-tag wine_campaign --cohort-start 2026-07-01 --cohort-end 2026-07-07

To queue an immediate discovery run for a motion through the same launch gate used by the operator surface:

audienti motions run-discovery <motn_id>

Outbound, inbound, and LOPA motions are accepted only when their current configuration and discovery producer are executable. An accepted response includes a durable run receipt that starts in pending before the discovery job is queued. Rejected launches exit nonzero and report the authoritative reason, optional next_eligible_at, and suggested_action; --json preserves that structured response on stdout for automation. Completed receipts keep candidate submitted_count separate from the current persisted promoted_count, and expose completed, failed, and blocked scope counts.

To check whether a motion has executable configuration before preparing, activating, or running discovery:

audienti motions status <motn_id>
audienti motions status <motn_id> --json

The JSON response includes executable_configuration.valid plus a reason when the config is incomplete, such as missing outbound signals or missing LOPA tracked profile URLs. Its latest discovery receipt uses the same submitted, promoted, and scope outcome fields as run-discovery.

To create and launch a quick-start motion from a company URL:

audienti motions quick-start --url https://example.com --wait --confirm

To create or update an ICP from a rich JSON payload:

audienti icps create --payload icp.json
audienti icps update <icp_id> --payload icp-patch.json
audienti icps list --status all
audienti icps archive <icp_id>
audienti icps restore <icp_id>

icps update --payload accepts the same human-readable facet keys as create. Supplied facet collections, such as company_sizes_attributes, replace that collection in place; omitted fields and collections remain unchanged. Invalid lookup values fail server-side without partially applying the patch. Archive is reversible and is the normal cleanup action. It removes the ICP from new selection, closes active primary motions so admitted work can drain, archives inactive primary motions, and preserves secondary motion links. Restoring the ICP does not reactivate motions.

To audit one account user's outbound actions, optionally narrowed to one motion and one AccountProspect.created_at cohort:

audienti analytics users --user me --start 2026-07-01 --end 2026-07-07 --cohort-start 2026-06-01 --cohort-end 2026-06-30 --motion <motn_id>

To start a report-backed writer session for one prospect, including the no-reply path, planned actions, channel changes, and planned message rows:

audienti writer test-run <prsp_id>

The output includes a Report: rprt_... id. Treat that report id as the writing session handle while the generated report is retained.

To draft every message into that report-backed session, opt into full report mode:

audienti writer test-run <prsp_id> --mode report --report <rprt_id>

For writer debugging, draft only one selected timeline row on one branch into the same report:

audienti writer test-run <prsp_id> --mode step --branch no-accept --step 3 --report <rprt_id>

The CLI queues the report job on the API and polls until the report finishes, so slower writer calls do not depend on a single long HTTP request. Use --timeout-seconds <n> to adjust the CLI wait budget.

To queue work into the report and come back later:

audienti writer test-run <prsp_id> --mode step --branch no-accept --step 3 --report <rprt_id> --no-wait

If the CLI stops waiting before the server job finishes, fetch the completed report later with:

audienti writer test-run show <prsp_id> <rprt_id>

To update a prospect's attached profile channels through the same paths used by the prospect show page:

audienti prospects add-profile <prsp_id> --url [email protected]
audienti prospects add-profile <prsp_id> --url +12025550123
audienti prospects add-profile <prsp_id> --url https://www.linkedin.com/in/example
audienti prospects report-bad-profile <prsp_id> <prof_id>

To queue a personal LinkedIn profile authority review and ICP-fit positioning blueprint, then check whether it is waiting on enrichment, running, completed, or failed:

audienti tools list
audienti tools linkedin-review --url https://www.linkedin.com/in/example --icp <icp_id>
audienti tools linkedin-review reports
audienti tools linkedin-review show <rprt_id>
audienti tools linkedin-review status <rprt_id>

To reassign or clear ownership for existing prospects:

audienti prospects assign <prsp_id> --assigned-user <account_user_id|me>
audienti prospects assign <prsp_id> --assigned-user unassign

To preview moving a prospect and its account-scoped history into another account where you are also an administrator:

audienti prospects move-account <prsp_id> --account <source_acct_id> --target-account <target_acct_id>
audienti prospects move-account <prsp_id> --account <source_acct_id> --target-account <target_acct_id> --assigned-user me --target-motion <motn_id> --target-list <list_id> --apply

The command is preview-only unless --apply is present. Apply always requests a fresh preview first and submits the returned manifest_digest, so a move is rejected when the underlying state changes. --json prints the preview or final apply response unchanged.

To make emergency prospect state changes without going through a motion:

audienti prospects set-status <prsp_id> --status nurture
audienti prospects set-status <prsp_id> --status not_fit
audienti prospects lock <prsp_id> --note "Emergency hold"
audienti prospects unlock <prsp_id>

To manage account DNC and company disposition rules from the CLI:

audienti dnc add [email protected]
audienti dnc import --file dnc.txt
audienti company-rules create --linkedin-url https://www.linkedin.com/company/example --disposition monitor
audienti company-rules create --domain example.com --disposition not_fit --user me
audienti company-rules apply --all

The direct intake action supports the same destination names and optional experiment:

audienti prospects intake --url https://www.linkedin.com/in/example --new-list "Target list" --new-transition "Fit transition" --json

Use --motion <motn_id> for an existing experiment. Explicit new names, including blank names, are sent to the API for validation.

To import multiple LinkedIn people through the same per-prospect import path:

audienti prospects import-batch --file prospects.csv --new-list "Target list" --new-transition "Fit transition" --assigned-user me

CSV files should include a linkedin_url or url header. Optional row columns list_id, motion_id, new_list_name, new_transition_name, and assigned_user_id override command defaults. The command parses the file and sends one batch request; the API owns validation, destination creation, row outcomes, and queueing.

Compatibility

The CLI talks to the versioned Audienti /api/v1 contract at https://app.audienti.com by default. A release occurs only after the matching server deploy succeeds.

The canonical source lives with the Audienti application under packages/audienti-cli. This public repository is a CI-managed mirror; direct changes are unsupported and cause the next source release to fail safely.

Plugins

This repository includes Codex and Claude Code plugin manifests plus an audienti skill. The plugin provides workflow instructions; it does not grant credentials or silently authenticate an agent.

License

Copyright (c) 2026 OMALab, Inc. All rights reserved. See LICENSE.

Batch import accepts up to 50 rows per API request. Split larger files before importing. Row destination IDs or new names override batch defaults; failed rows stay visible in the response. Bulk destinations: audienti prospects set-destination <prsp_id> --type list --destination <list_id> adds by default. Use --name "New list" to create a list, --type experiment --name "Existing relationships" to create a transition without setup, or --mode move for explicit reassignment. Add preserves existing memberships; experiment Add skips people assigned elsewhere.

Create a child workspace with audienti accounts create --name <name> --parent <name-or-id> [--json]. The parent can be a visible name, unique name fragment, numeric ID, or prefixed ID. You must administer a root team account. All parent admins receive access to the child; ordinary members do not. Ambiguous names show matching IDs and stop. A duplicate child name under the same parent fails clearly. The response includes the new account ID. Creation keeps your selected account unchanged: use audienti accounts select <new_acct_id> or --account <new_acct_id> before creating a motion there.