MCP Server Reference

Model Context Protocol (MCP) Server

Machine-derived from packages/core/src/lib/capabilities/catalog.ts and apps/mcp/src/index.ts. Regenerate with node scripts/gen-docs.mjs.

AICMOHQ ships a stdio MCP server (aicmohq-mcp v0.1.0) inside the aicmo CLI. Tools are built from the shared capability registry — the same definitions power the dashboard API, CLI, AI CMO chat, and public mcp.json.

Approval-first: nothing posts or sends externally without a human approving it in AICMOHQ first. queue_publish only publishes items a human already approved.

Prerequisites

Install the CLI: npm install -g @aicmohq/cli (monorepo: pnpm --filter @aicmohq/cli build then use packages/cli/dist/aicmo).
Authenticate once: aicmo login (device flow at /activate) or create an agent token in the dashboard and set AICMOHQ_API_KEY.
Confirm the server starts: aicmo mcp (blocks on stdio — cancel with Ctrl+C).

Only capabilities_list and credit_costs run without a bearer token. Every other tool calls https://app.aicmohq.com/api/v1/* (or your configured base URL).

Authentication

Bearer token resolution order (see apps/mcp/src/index.ts):

MCP server environment: AICMOHQ_API_KEY, AICMOHQ_TOKEN, AICMO_API_TOKEN, or AICMO_TOKEN
~/.aicmo/config.json from aicmo login (AICMO_HOME overrides the directory)

Per-tool token / baseUrl arguments are disabled by default (AICMOHQ_ALLOW_TOOL_OVERRIDES must be true). Never enable overrides on a shared machine.

Prefer agent tokens (aicmo token create --name "cursor") with the minimum scopes for your host. User tokens (aicmo_usr_… from login) carry every scope.

API base URL

Default: https://app.aicmohq.com. Override with AICMOHQ_API_URL or AICMO_URL on the MCP server process.

Environment variable	Purpose
`AICMOHQ_TRUSTED_API_ORIGINS`	Comma-separated origin allow-list; startup `AICMOHQ_API_URL` must match (default includes production + Cloudflare workers dev host).
`AICMOHQ_ALLOW_LOCAL_API=true`	Required to use `http://localhost` / `127.0.0.1` as the API base.
`AICMOHQ_ALLOW_TOOL_OVERRIDES=true`	Allows per-call `token` / `baseUrl` tool arguments (off by default).
`AICMOHQ_MCP_BIN`	Optional path to an external MCP binary; when set, `aicmo mcp` spawns it instead of the in-process server.

Local dev example (monorepo app on port 3000):

{
  "mcpServers": {
    "aicmohq": {
      "command": "aicmo",
      "args": ["mcp"],
      "env": {
        "AICMOHQ_API_URL": "http://localhost:3000",
        "AICMOHQ_ALLOW_LOCAL_API": "true",
        "AICMOHQ_TRUSTED_API_ORIGINS": "http://localhost:3000",
        "AICMOHQ_API_KEY": "aicmo_usr_…"
      }
    }
  }
}

Client configuration (copy-paste)

All clients use stdio: command aicmo, args ["mcp"]. Put secrets in the server env, not in the JSON file committed to git.

Claude Code

claude mcp add aicmohq -- aicmo mcp

Set AICMOHQ_API_KEY in your shell or Claude Code MCP env if you did not run aicmo login.

Cursor

Settings → MCP → Add server, or project file .cursor/mcp.json:

{
  "mcpServers": {
    "aicmohq": {
      "command": "aicmo",
      "args": ["mcp"],
      "env": { "AICMOHQ_API_KEY": "aicmo_agt_YOUR_TOKEN" }
    }
  }
}

Claude Desktop

Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "aicmohq": {
      "command": "aicmo",
      "args": ["mcp"],
      "env": { "AICMOHQ_API_KEY": "aicmo_usr_YOUR_TOKEN" }
    }
  }
}

Restart Claude Desktop after saving.

OpenAI Codex CLI

Add to ~/.codex/config.toml:

[mcp_servers.aicmohq]
command = "aicmo"
args = ["mcp"]
env = { AICMOHQ_API_KEY = "aicmo_usr_YOUR_TOKEN" }

Restart Codex so it reloads MCP servers.

Windsurf / Cline / OpenCode / other JSON hosts

Use the same mcpServers block as Cursor. Typical paths: Windsurf MCP config in the editor settings UI; Cline .cline/mcp_settings.json; OpenCode opencode.json under mcp.

Zed

Add a custom context server in settings.json (stdio):

{
  "context_servers": {
    "AICMOHQ": {
      "command": { "path": "aicmo", "args": ["mcp"], "env": { "AICMOHQ_API_KEY": "aicmo_usr_YOUR_TOKEN" } }
    }
  }
}

Tool annotations

Each tools/list entry includes MCP annotations derived from the registry (toMcpTool in packages/core/src/lib/capabilities/registry.ts):

readOnlyHint — effect === "read"
destructiveHint — external_write or delete
idempotentHint — idempotency is not non_retryable
openWorldHint — external_write

Typical flows

research → draft → approve → publish
  scout {keywords}                         → opportunities
  write {platform, topic, enqueue:true}    → queue item (draft)
  queue_approve {id}                       → approved (human)
  queue_publish {id}                       → posts (needs publish scope + connection)

AI CMO command loop
  command_chat {message}                   → plan + message id
  command_run {messageId}                  → NDJSON progress (approval-first)

Assisted channels (Hacker News / Product Hunt)
  queue_proof {id, proofUrl}               → then queue_publish {id}

X threads: one string with --- between tweets, ≤280 characters per segment.

Errors

Failures return MCP isError: true with JSON text:

{ "error": { "code": "missing_auth_token", "message": "…", "status": 401, "retryable": false } }

Stable codes from the server include missing_auth_token, invalid_arguments, unknown_tool, untrusted_auth_override, untrusted_api_base_url, invalid_api_response, http_<status>, plus API codes such as publish_not_approved, insufficient_credits, and reddit_not_connected. Retry only when retryable is true (5xx / transport).

Troubleshooting

Symptom	Likely cause	Fix
`missing_auth_token` on every tool	No env token and no `~/.aicmo/config.json`	Run `aicmo login` or set `AICMOHQ_API_KEY` on the MCP server env
`command not found: aicmo`	CLI not on PATH for the GUI app	Install globally or use the full path to the binary in `command`
`untrusted_api_base_url`	Local/staging URL without allow-list	Set `AICMOHQ_ALLOW_LOCAL_API=true` and add the origin to `AICMOHQ_TRUSTED_API_ORIGINS`
HTTP 403 on agent token	Missing OAuth scope for the capability	Use a user token or recreate the agent token with the required scope
HTTP 402	Out of credits	Top up or upgrade plan in the dashboard
HTTP 409 `*_not_connected`	Platform OAuth missing	Connect the channel in Settings → Connections, then retry
`unknown_tool`	Stale MCP client cache	Restart the MCP server / reload tools in the host
Server exits immediately	Wrote logs to stdout	The server uses stdio for JSON-RPC — do not wrap it with scripts that print to stdout
Host shows old tool list	MCP session started before CLI upgrade	Restart the MCP server process after upgrading `@aicmohq/cli`

Manual handshake (developers):

echo '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}' | aicmo mcp

Tool catalog

179 tools (MCP surface). Names match tools/list; descriptions match cap.description in the registry.

account

connections_list — List connected platforms (check LinkedIn before publishing). · scope connections:read
me_get — Read the authenticated identity: user id, token type, and granted scopes. · scope billing:read

analytics

analytics_attribution — Read attribution: which content and channels drove signups. · scope analytics:read
analytics_benchmarks — Read ad benchmarks (beta): your CTR/CPC/CPA against the anonymized pool for a platform, optionally narrowed by industry, campaign type, objective and country. Returns status not_enough_data, with no numbers, until the pool has enough real contributors. · scope analytics:read
analytics_overview — Read aggregate performance over the last N days: totals per metric, per platform, and queue status. · scope analytics:read
analytics_pagespeed — Run a PageSpeed check on a public url and return its performance scores. · scope analytics:read
analytics_report — Read the rolled-up performance report for the last N days (default 7). · scope analytics:read

approvals

approvals_approve — Record a human approval, which releases the item to publish. Agents must not call this on their own drafts. · scope publish
approvals_list — List items waiting for a human approval decision. · scope queue:read
approvals_reject — Reject a pending approval so the item is never published. · scope queue:write

artifacts

artifacts_list — List agent artifacts (research briefs, drafts, reports) produced for this workspace. · scope strategy:run

beacon

audience_create — Add one subscriber to the email audience. A consent source is recorded for compliance (defaults to manual). · scope workspace:write
audience_import — Import subscribers from CSV with a required consent source. · scope workspace:write
audience_list — List the email marketing audience for the workspace, with status and segment filters. · scope strategy:run

billing

billing_status — Read the active plan, credit balance, and renewal date. · scope billing:read

brief

brief_get — Read the most recent stored daily brief: yesterday’s shipped items, engagement, pending actions, and alerts. · scope queue:read

campaigns

ads_get — Agni AdKit: Read one ad launch by id. · scope analytics:read
ads_launch — Agni AdKit: Plan (dry_run=true, default) or execute an ad launch. Execution is policy-gated: winner score >= 60 creates a paused campaign draft, below that it lands pending_approval for human sign-off — nothing ever goes live directly. Proposes a command plan; execute only after human approval. · scope campaigns:write
ads_launches — Agni AdKit: List launched/paused/pending ad campaigns in the workspace. · scope analytics:read
ads_manage — Agni AdKit: Manage one launch: action approve|activate|pause|archive (approve pending_approval -> paused; activate paused -> active; pause active -> paused; archive any -> archived) and/or set daily_budget. Proposes a command plan; execute only after human approval. · scope campaigns:write
ads_performance — Agni AdKit: Performance for one launch: spend, impressions, clicks, conversions, CTR, CPA, ROAS. synced:false + zeros until a platform metrics sync has written data. · scope analytics:read
advocates_list — Advocate leaderboard: repeat positive engagers scored on reach(momentum), loyalty, content and amplification, tiered micro_influencer/loyal_customer/ugc_creator/advocate. · scope advocacy:read
advocates_outreach — Ready-to-send DM template for one advocate, worded per tier (micro-influencer affiliate offer, loyal-customer early access, UGC feature request). · scope advocacy:read
advocates_set_status — Mark an advocate contacted / partner / dismissed once you’ve reached out. · scope advocacy:write
autopilot_actions — List autopilot proposals — pending ones awaiting a decision, or applied/dismissed history. · scope autopilot:read
autopilot_decide — Decide one autopilot proposal: apply executes it (scale budget / pause launch / pause loop), dismiss closes it without side effects. · scope autopilot:write
autopilot_learnings — The readable learning files the loops append to each run — winner/miss/audit/digest lessons per channel with the rows that earned them. · scope autopilot:read
autopilot_run — Run one autopilot cycle now (or the weekly audit with loop=audit). Deterministic — grades signals, writes learnings, proposes actions. No credits; proposals still need approval. · scope autopilot:run
autopilot_status — Autopilot rollup: active loops, cycles run, pending proposals, learnings this week, plus every loop’s last-run state. · scope autopilot:read
campaigns_archive — Delete a campaign. · scope campaigns:write
campaigns_create — Create a campaign. Pass a node/edge graph to define its steps, or omit it for an empty draft. · scope campaigns:write
campaigns_get — Read one campaign including its full step graph. · scope strategy:run
campaigns_list — List campaigns (multi-step marketing graphs) in the workspace. · scope strategy:run
campaigns_update — Update a campaign’s name, status (draft/active/archived), or step graph. · scope campaigns:write
sentiment_series — Daily per-platform sentiment rollup (positive/neutral/negative %) plus live anomalies vs the 7-day baseline — the crisis early-warning feed. · scope sentiment:read

command

command_approve_step — Approve one bound CMO step so execution resumes (expires in 15 minutes). · scope strategy:run
command_chat — Send a natural-language mission to AICMOHQ Agent. Persists session memory and returns a proposed plan (approval-first; does not publish). When the response includes a plan, executionPolicy tells you the next step: call command_run with message.id to execute (auto=true only when auto_run_eligible), or command_status with runId to inspect a running one. · scope strategy:run
command_run — Execute a proposed command plan by assistant message id. Rejects auto=true when approval is required. Streams NDJSON progress. · scope strategy:run
command_sessions — List recent AICMOHQ Agent chat sessions (shared memory with dashboard + CLI). · scope strategy:run
command_status — Inspect a durable command run and its approval-gated steps. · scope strategy:run

creative

creative_abort — Abort an in-flight Creative Studio generation job; credits are refunded when the provider had not yet spent them. · scope creative:run
creative_assets — List signed output assets for a completed creative run. · scope creative:read
creative_cancel — Cancel a creative run and refund unstarted stages. · scope creative:run
creative_compositions_get — Read the latest motion composition (template, variables, version) for each scene of a creative run. · scope creative:read
creative_compositions_set — Edit one motion scene: set template variables, or mode=freeform with an engine and instruction (LLM-written code, billed). Writes a new version and a fresh storyboard approval; nothing renders until a human approves. · scope creative:run
creative_gallery — List Creative Studio generation jobs with signed output URLs, newest first. · scope creative:read
creative_generate — Generate a Creative Studio image, video or carousel (pass slides 2-6 for a carousel — one render per slide, poll creative_job to see slides land). Debits credits and drafts the result into the content queue for approval; never publishes. · scope creative:run
creative_job — Read one Creative Studio generation job and its signed output URL. Carousels list per-slide media_urls, filling toward slides while rendering. · scope creative:read
creative_models — List the active Creative Studio generation models with their credit cost per billing unit. · scope creative:read
creative_plan — Derive a video storyboard: a launch video from productUrl (screen capture), or with mode “motion” a motion-graphics video from a prompt. Creates an approval; does not render or publish. · scope creative:run
creative_queue — Create content_queue drafts from a completed creative run. Does not publish. · scope queue:write
creative_render — Start rendering an approved storyboard. Heavy work runs on the media worker. · scope creative:run
creative_review — Read the storyboard awaiting approval for a run. · scope creative:read
creative_revise — Open a new storyboard revision that supersedes a previous run. Does not render or publish. · scope creative:run
creative_status — Read a creative run, its stages, and signed preview URLs. · scope creative:read
creative_storyboard_edit — Edit a run’s timeline with 1-20 ordered ops: reorder, trim, remove, add_upload, add_template. Free; the result needs a fresh storyboard approval before it renders. · scope creative:run
creative_variants — Create up to 5 A/B copy variants of one motion scene as sibling runs, each needing its own approval. Does not render or publish. · scope creative:run
ugc_batch — Generate a batch of UGC-style creator ad videos — one keyed job per deterministic hook angle. Whole-batch quota is reserved before any spend; per-angle failures return as data. Results land in the review gallery; never publishes. · scope creative:run
ugc_batch_preflight — Read-only readiness check for a UGC batch: engine key, model, quota, credits, consent, product context and platform connections. Returns fixable blockers plus the server-computed credit total. · scope creative:read
ugc_performance — Rank UGC batch hook angles by attributed revenue (GA4 first-touch). Hooks without pulled metrics report null — never a fabricated zero. · scope analytics:read
ugc_scale — Hand a proven UGC hook to the paid lane — resolves the winning video and creates an ads.launch (creative_url = the video). Lands pending_approval or paused exactly like any launch. · scope campaigns:write

discovery

adlib_ack_alerts — Agni AdKit: Mark launch alerts read. Omit ad_ids to acknowledge everything unread. Proposes a command plan; execute only after human approval. · scope discovery:run
adlib_alerts — Agni AdKit: Competitor ads seen for the first time — the launch-alert feed. · scope discovery:read
adlib_boards — Agni AdKit: List swipe-file boards with save counts and public-share metadata. · scope discovery:read
adlib_browse — Agni AdKit: Browse ads already stored in the workspace’s ad library. Sort by score for Ad Score (beta). Tiers are high_conf | winner | emerging | loser. · scope discovery:read
adlib_clone — Agni AdKit: Remix an ad’s hook into 3 deterministic variants for your own creatives. Proposes a command plan; execute only after human approval. · scope discovery:run
adlib_competitors — Agni AdKit: List the competitor watchlist merged with advertisers already seen in the library. · scope discovery:read
adlib_create_alert_rule — Agni AdKit: Create a competitor, new-ad, or score-threshold monitoring rule. Proposes a command plan; execute only after human approval. · scope discovery:run
adlib_create_board — Agni AdKit: Create a named swipe-file board. Proposes a command plan; execute only after human approval. · scope discovery:run
adlib_get_ad — Agni AdKit: Read one stored ad by its ad_id. · scope discovery:read
adlib_get_score — Agni AdKit: Read Ad Score (beta) for one ad: overall 0-100 plus a transparent breakdown (run duration, variants, creative reuse, still active). · scope discovery:read
adlib_list_assets — Agni AdKit: List creative assets in the workspace ranked by reuse count (how many ads share the same primary creative). · scope discovery:read
adlib_monitoring — Agni AdKit: Read weekly digest and monitoring preferences. · scope discovery:read
adlib_save_ad — Agni AdKit: Save an ad to a swipe-file board (Unsorted when omitted). Proposes a command plan; execute only after human approval. · scope discovery:run
adlib_saved — Agni AdKit: List saved ads with per-board counts and swipe-file filters. · scope discovery:read
adlib_search — Agni AdKit: Collect competitor ads from the public ad libraries (Meta/Google/LinkedIn/TikTok/X) for a query, persist them, and return the scored page. Costs ad_library_scan credits; a live scan can take 15-40s. Proposes a command plan; execute only after human approval. · scope discovery:run
adlib_set_board_public — Agni AdKit: Enable or disable a read-only public link for a swipe-file board. Proposes a command plan; execute only after human approval. · scope discovery:run
adlib_set_digest — Agni AdKit: Enable or disable the existing weekly competitor digest. Proposes a command plan; execute only after human approval. · scope discovery:run
adlib_sync_competitor — Agni AdKit: Track a competitor and refresh-pull its live ads now. Costs ad_library_scan credits; new ads raise alerts. Proposes a command plan; execute only after human approval. · scope discovery:run
adlib_top_spend — Agni AdKit: Find top stored ads ranked by estimated library spend; missing spend stays unknown. · scope discovery:read
adlib_track_competitor — Agni AdKit: Add a competitor name to the watchlist (idempotent). Proposes a command plan; execute only after human approval. · scope discovery:run
adlib_unsave_ad — Agni AdKit: Remove an ad from a board (default board when omitted). Proposes a command plan; execute only after human approval. · scope discovery:run
adlib_untrack_competitor — Agni AdKit: Remove a competitor from the watchlist. Proposes a command plan; execute only after human approval. · scope discovery:run
adlib_weekly_digest — Agni AdKit: Read the last seven days of competitor ad activity without sending email. · scope discovery:read
ads_benchmarks — Agni AdKit: Read anonymized ad benchmarks with the existing contributor privacy floor. · scope analytics:read
ads_report — Agni AdKit: Read ad spend and performance by platform and project. · scope analytics:read

echo

echo_mentions — List tracked brand and competitor mentions. · scope analytics:read
echo_scan — Scan tracked sources for brand and competitor mentions. · scope strategy:run
listening_alert_preview — Preview the email and Slack payload for a spike or high-intent alert. Local and read-only; never sends notifications. · no auth (local)
listening_listeners — Boolean keyword listeners with negative keywords. Actions: list, add, remove, match. · no auth (local)
listening_score — Score a mention feed for relevance, buying intent, and sentiment. Omit mentions to score the built-in demo. Local and read-only; nothing is sent or published. · no auth (local)
listening_sov — Brand versus competitor mention counts for a weekly share-of-voice snapshot. · no auth (local)

engage

engage_high_intent_draft — Turn a high-intent mention into a Mitra reply draft for the approval queue. Returns the draft payload only. Nothing is sent. · no auth (local)
engage_reply_drafts — List Mitra’s pending reply drafts — answers to new comments on your published posts and to negative brand mentions, waiting in the queue for approval. · scope queue:read
engage_scan — Run Mitra’s engagement sweep for your workspace: drafts replies to new comments on your published posts and answers negative brand mentions. Everything lands as queue drafts for approval — nothing posts. · scope strategy:run

feed

feed_list — Read the agent activity feed — what the agents did and what needs attention. · scope strategy:run
feed_update — Mark one feed item as read or acted on. · scope strategy:run

geo

geo_checklist — Read the GEO readiness checklist (signal, status) plus which sources already cite the product. · scope strategy:run
geo_citations — Citation check for a saved prompt set. The demo uses fixtures for ChatGPT, Perplexity, and Gemini. Other engines are stubs. mode=live uses configured API keys and does not invent results. · no auth (local)
geo_competitors — List competitor citation share and latest GEO visibility data. · scope strategy:run
geo_crawler_audit — Report whether robots.txt allows GPTBot, ClaudeBot, PerplexityBot, and Google-Extended. Does not edit the file. · no auth (local)
geo_gap_draft — Build an FAQ, schema JSON-LD, or short outline for a citation miss. The result is a draft. Nothing is published. · no auth (local)
geo_prompts — Prompt library for a category, with optional question-shaped Search Console queries. Actions: list, seed, add, update, remove, scan. Scan uses fixtures unless you run a live GEO scan. · no auth (local)
geo_scan — Run a GEO scan to check whether AI assistants cite the product. Costs credits. · scope geo:run
geo_status — Read current GEO (AI-citation) status: which AI answers mention the product. · scope strategy:run
geo_uncited — List high-value GEO queries where the product is not cited. · scope strategy:run

growth

listening_list — List captured listening mentions — places the product or its category was discussed. · scope strategy:run
listening_scan — Run a listening scan for new mentions of the product. Costs credits. · scope strategy:run
opportunities_draft — Draft content for an opportunity. Costs credits; the draft still needs human approval to publish. · scope strategy:run
opportunities_list — List scored growth opportunities derived from listening and signals. · scope strategy:run
opportunities_queue — Move an opportunity’s draft into the content queue as a pending item. · scope queue:write
recommendations_decide — Accept or dismiss one recommendation. Accepting is what changes prioritization. · scope strategy:run
recommendations_generate — Regenerate the recommendation set from the latest workspace data. · scope strategy:run
recommendations_list — List the CMO’s current recommendations for the workspace. · scope strategy:run
signals_scan — Search external sources for demand signals matching a query. · scope strategy:run
trends_list — Read trending topics for the day or week to ground timely content. · no auth (local)

inbox

inbox_get — Read one contact’s full inbox thread. · scope strategy:run
inbox_list — List inbox conversations with prospects across email and DMs. · scope strategy:run
outreach_draft — Draft an outreach message to a contact and queue it for human approval. Nothing is sent — approve and publish the queued item to actually deliver it. · scope outreach:write

integrations

connections_health — Check each connected platform’s token health before trying to publish. · scope connections:read
crm_sync — Push a contact to the connected HubSpot CRM. Writes to an external system, so it needs approval. · scope outreach:write
ga4_pull — Pull the latest metrics from the connected GA4 property. · scope analytics:read
github_repos — List repos visible through the connected GitHub account, for shipping-log content. · scope connections:read

launch

launch_prepare — Prepare launch assets (Product Hunt / Hacker News copy) for a product. Submission stays human-assisted. · scope strategy:run
listings_archive — Remove a tracked launch listing. · scope workspace:write
listings_create — Track a new directory launch listing. Records intent only; submission stays human-assisted. · scope workspace:write
listings_list — List directory launch listings (Product Hunt, Hacker News, directories) tracked for the workspace. · scope strategy:run
listings_update — Update a tracked launch listing (status, URL, notes). · scope workspace:write

products

products_archive — Delete a product. Its past artifacts stay, but new work can no longer target it. · scope workspace:write
products_create — Add a product to the workspace so scans and drafts can be scoped to it. · scope workspace:write
products_list — List the products in the workspace. Most agent work needs a product_id from here first. · scope strategy:run
products_update — Update a product’s name, tagline, description, or url. · scope workspace:write

prospects

prospects_scan — Scan for prospects matching the workspace ICP. Costs credits. · scope strategy:run

queue

queue_approve — Approve a draft queue item so it can be published. Human-only: the API rejects CLI/MCP tokens. · scope queue:write
queue_best_time — Suggest the best publish time for a platform — the workspace’s measured engagement history when available, else the platform’s researched golden-hour window. Advisory only; scheduling still goes through queue_schedule. · scope queue:read
queue_delete — Permanently delete a queued draft. · scope queue:write
queue_get — Fetch one content queue item by id. · scope queue:read
queue_list — List content queue items for the authenticated AICMOHQ account. · scope queue:read
queue_proof — Save a live post URL for Hacker News or Product Hunt (no API). Then call queue_publish to mark the item published. · scope queue:write
queue_publish — Publish an approved queue item (requires platform connection, e.g. LinkedIn). · scope publish
queue_reject — Reject a draft so it will not publish. · scope queue:write
queue_schedule — Schedule an approved queue item for cron publish (ISO timestamp). · scope queue:write
queue_update — Update the content of a queued draft. · scope queue:write

reddit_status — Inspect the connected Reddit account’s conservative warm-up stage and engagement limits. · scope connections:read
reddit_warmup — Use the connected Reddit OAuth account to find value-first threads. Saves opportunities only; never comments or publishes. · scope strategy:run

scout

scout — Find marketing opportunities based on product and keywords. · scope strategy:run

settings

agent_mode_get — Read the publishing mode (approve or autonomous) plus any per-agent overrides. · scope strategy:run
agent_mode_set — Change the publishing mode. Switching to autonomous removes the human approval gate, so it needs a human. · scope settings:write
email_prefs_get — Read the account email preferences: onboarding emails and the daily brief. · scope strategy:run
email_prefs_set — Change account email preferences. Agents may only opt OUT (false); opting in is consent and needs a human in the dashboard. · scope settings:write
voice_get — Read canonical workspace brand voice. · scope strategy:run
voice_set — Update canonical workspace brand voice with optimistic revision control. · scope settings:write

strategy

strategy_docs_get — Read the saved strategy documents and plan for a product (defaults to the primary product). · scope strategy:run
strategy_docs_save — Generate the strategy documents for a product and save them. Spends credits. · scope strategy:run
strategy_run — Run the full strategy loop: extract git context and generate ICP-validated drafts into the queue (LinkedIn, X, Reddit). · scope strategy:run

tasks

scheduled_tasks_create — Create a scheduled task: a prompt the agent runs on a cadence. Each run spends credits unattended. · scope workspace:write
scheduled_tasks_delete — Permanently delete a scheduled task. · scope workspace:write
scheduled_tasks_list — List scheduled tasks (recurring agent prompts) and their recent runs. · scope queue:read
scheduled_tasks_run — Run a scheduled task now. Spends credits; does not move its schedule. · scope workspace:write
scheduled_tasks_update — Update a scheduled task’s title, prompt, cadence or status (pause/resume). · scope workspace:write
tasks_approve — Approve a task that is waiting for a human decision. Never approve your own work. · scope strategy:run
tasks_create — Queue a task for one of the agents (scout, writer, publisher, engage, analyst). · scope strategy:run
tasks_execute — Run an approved task now instead of waiting for the scheduler. · scope strategy:run
tasks_get — Read one task with its input, result, and error. · scope strategy:run
tasks_list — List agent tasks, optionally filtered by status or agent. · scope strategy:run
tasks_update — Update a task’s status, result, or error. · scope strategy:run

workflows

workflows_execute — Execute a named workflow synchronously with a small input map. Costs credits. · scope strategy:run
workflows_start — Start a background workflow (e.g. reddit_scan, hn_scan, content drafts) for a product. Costs credits. · scope strategy:run
workflows_status — Read a running workflow’s status and step results. · scope strategy:run

workspace

workspace_context — Read the workspace strategy context (product, ICPs, positioning, brand voice) agents ground drafts on. · scope strategy:run
workspace_get — Read the raw workspace record (company profile, positioning, ICPs) the agents ground on. · scope strategy:run

writer

write — Draft content from a topic or from recent git commits. Set enqueue=true to put the draft in the queue for LinkedIn/X publish. · scope strategy:run

Discovery

Live HTTP catalog: GET https://app.aicmohq.com/api/v1/capabilities
Public manifest: https://aicmohq.com/mcp.json
Full capability table (all surfaces): Capabilities reference