Reference

Integrations

Argus speaks the Model Context Protocol, so an agent that already knows how to use tools can drive your profiles without being taught an API. Connecting installs nothing.

On this page

Agents over MCP

MCP is how a coding agent discovers what a program can do. The agent asks for a tool list, gets one back with names, descriptions and argument schemas, and calls what it needs — no wrapper, no SDK, nothing to keep in step with a changelog.

The Argus server runs from inside the launcher's own application bundle, started with ELECTRON_RUN_AS_NODE. There is no package to install and nothing new listening: it speaks JSON-RPC over stdin and stdout to the client that launched it, and reaches the local API on your behalf.

For most clients the launcher writes the config file for you and shows you the path first. Two of them have no file it can write, and say so by handing over a snippet instead.

This is a local API. It listens on loopback on the machine running Argus, and nothing off that machine can reach it. There is no hosted web API.

Supported clients

Coding agents

Claude Code

Anthropic's coding agent CLI. Drive profiles as tools from any project.

Config: ~/.claude.json
Key: mcpServers.argus

Run /mcp in any project — argus should be in the list.

Codex

OpenAI's coding agent CLI. Same tools, wired into Codex's own config.

Config: ~/.codex/config.toml
Key: [mcp_servers.argus]

Codex reads its MCP servers at startup — ask it what tools it has and the argus ones should be there.

Cursor

The AI editor. Registered in Cursor's global MCP config.

Config: ~/.cursor/mcp.json
Key: mcpServers.argus

Open Cursor Settings → MCP: argus should be listed and switched on.

Gemini CLI

Google's coding agent CLI. Same tools, in its own settings file.

Config: ~/.gemini/settings.json
Key: mcpServers.argus

Run /mcp — argus should be in the list.

Windsurf

The Codeium editor. Registered for Cascade to use.

Config: ~/.codeium/windsurf/mcp_config.json
Key: mcpServers.argus

Open Cascade's plugin panel: argus should be listed there.

VS Code

Agent mode in Visual Studio Code, through its user MCP config.

Config: Code/User/mcp.json
Key: servers.argus

Switch Chat to Agent mode and open the tools picker — the argus tools should be listed.

Zed

Zed's agent panel, through its context server settings.

Config: ~/.config/zed/settings.json
Key: context_servers.argus

Check the agent panel's settings: argus should appear under context servers.

Automation

OpenClaw

Personal assistant gateway across chat channels.

Config: ~/.openclaw/openclaw.json
Key: mcp.servers.argus

It loads its config at startup — argus should show up among its tools.

Set up by hand

These two have no config file Argus can write. Connecting them means handing over a snippet rather than pretending to wire them up.

Hive

by hand

Multi-agent runtime. Run QA and monitoring sweeps across many profiles at once.

Config: its own .env
Key: environment variables

Hive reads the .env at startup — its first sweep will use this key.

Any other MCP client

by hand

Anything that speaks MCP. Copy the server block into its config yourself.

Config: whatever your client reads
Key: mcpServers.argus

Your client should list argus among its MCP servers once it is back up.

Setting it up by hand

For everything above except Hive and “any other MCP client”, Argus writes this block for you and shows you the file path before it touches anything. If you would rather do it yourself, or your client is not on the list, this is the shape.

mcp.json

{
  "mcpServers": {
    "argus": {
      "type": "stdio",
      "command": "Argus Launcher",
      "args": ["<the path shown after you connect>"],
      "env": {
        "ELECTRON_RUN_AS_NODE": "1",
        "ARGYS_API_TOKEN": "<your key>",
        "ARGYS_API_BASE": "http://127.0.0.1:39219"
      }
    }
  }
}

Hive reads environment variables out of its own .env instead:

.env

ARGYS_API_BASE=http://127.0.0.1:39219
ARGYS_API_TOKEN=<your key>

Restart the client afterwards. Every one of these reads its MCP config at process start and there is no reload signal Argus can send.

What an agent gets

39 tools, and the instructions the server hands the model on connect:

Drive Argus anti-detect browser profiles. Each profile is an isolated browser identity with its own proxy, fingerprint and cookie jar. Typical flow: argus_list_profiles, then argus_launch_profile, then argus_navigate / argus_read_page / argus_screenshot, then argus_close_profile. A launched session is anonymous — never send it credentials or tokens.

34 tools wrap an endpoint

argus_list_profiles

List profiles (optional ?folder=<id>)

argus_get_profile

Read one profile

argus_create_profile

Create a profile

argus_update_profile

Update name, status, tags, colour, avatar, folder, proxy mode, start URL or launch automation

argus_profile_notes

Read a profile's notes, newest first

argus_add_profile_note

Append a note to a profile

argus_assign_proxy

Put a profile on a proxy from the library

argus_launch_profile

Open a profile for automation; returns its CDP url. Reuses a running session unless relaunch is set

argus_profile_session

Where a running profile's CDP endpoint is, without launching it

argus_close_profile

Close a session this key opened

argus_delete_profile

Move a profile to Trash (permanent: true to purge; the tool only soft-deletes)

argus_update_fingerprint

Re-roll or override a profile's fingerprint

argus_list_proxies

List proxies

argus_check_proxy

Check reachability and egress IP

argus_list_automations

List the org's automations, with step counts

argus_automation_schema

The step catalogue: every step type, its fields and how they validate

argus_get_automation

Read one automation, including its full step tree

argus_create_automation

Create an automation. Steps are validated before anything is stored

argus_update_automation

Change an automation's name, description, steps or wiring

argus_delete_automation

Move an automation to Trash. It stops running on launch and on its schedule

argus_run_automation

Run an automation against a profile, launching it if needed

argus_automation_runs

Recent runs of one automation, with status and errors

argus_list_connectors

The workspace's connectors, and the field list of every kind

argus_create_connector

Add a connector. Owner-only, like the Connectors view

argus_update_connector

Rename a connector, change its config or make it the default

argus_delete_connector

Delete a connector

argus_test_connector

Send a real test message, or a one-word AI completion

argus_list_folders

The folders profiles, proxies, cookie sets and automations are filed in

argus_list_statuses

Every status label a profile, proxy or cookie set can carry

argus_telegram_status

Whether the notification bot is set up, and who is subscribed

argus_set_telegram_pref

Subscribe the signed-in user to one automation's outcomes

argus_set_telegram_bot

Set the workspace's notification bot. Owner-only

argus_table_columns

What each table shows, and every column it could show

argus_set_table_columns

Show or hide columns on a table

5 drive a page directly, with no endpoint behind them

argus_list_tabs

List the open pages in a running profile

argus_navigate

Point a page at a URL and wait for it to settle

argus_read_page

Read a page's visible text, whole or by CSS selector

argus_screenshot

Screenshot a page — JPEG by default, PNG on request

argus_eval

Evaluate a JavaScript expression in a page and return its value

7 endpoints have no tool at all — the destructive and bulk ones. They are listed on the API reference, marked HTTP only.

Automation connectors

Connectors are the outside services an automation can reach: a model to ask, somewhere to send the answer, and somewhere for a run's rows to land. A step stores a connector id and nothing else, so a key changes in one place and every automation using it follows.

Twelve AI entries share exactly two wire protocols. Eleven speak OpenAI's chat-completions shape, because each of them publishes an OpenAI-compatible endpoint; Claude is the one that is genuinely different. Two of the twelve run on your own machine and need no key at all.

The data connectors are where the save rows and load rows steps point. Each one carries its own container as well as its credential — a Sheets connector holds the spreadsheet, an Airtable one the base — so a step only ever names a single table, tab, key or file.

Connector credentials are stored in your workspace, readable by anyone in it who can open the connectors list — and returned in full over the local API, so an Argus API key is equivalent to the credentials it can read. Argus masks them in its own interface, but that is a convenience rather than a security boundary — give a connector the narrowest key the service will issue.

The new-connector picker listing twelve AI model presets, from ChatGPT and Claude to local LM Studio and Ollama, five messaging presets from Telegram to email over SMTP, and eight database and file presets from Supabase and Postgres to Redis and local files. — Every target an automation can reach: twelve AI model presets — hosted or local — five messaging presets, and eight databases and files.

Endpoint: http://127.0.0.1:1234/v1
Model: local-model
Needs: None — it runs on your machine

Ollama

OpenAI-compatible

Endpoint: http://127.0.0.1:11434/v1
Model: llama3.1
Needs: None — it runs on your machine

Other

OpenAI-compatible

Needs: Your own endpoint, and a key if it wants one

Anything that answers POST {base}/chat/completions. You supply the base URL.

Messaging

Where a notify step sends its message, and where a run tells you it finished. One adapter each: unlike model vendors, chat services never converged on a wire format.

Needs: Bot token and chat ID

From @BotFather. The bot must have messaged the chat once, or be in the group. Group ids are negative numbers.

Where to get a key

Slack

Needs: Incoming webhook URL

The URL is the credential — anyone holding it can post to the channel.

Where to get a key

Discord

Needs: Webhook URL

Where to get a key

Needs: Cloud API phone number ID, access token, and a recipient

Free-form messages only reach people who messaged this number in the last 24 hours; outside that window WhatsApp requires a pre-approved template.

Where to get a key

Email (SMTP)

Needs: Host, port, from and to — username and password where the relay wants them

Port 465 connects over TLS; anything else starts plain and upgrades with STARTTLS.

Databases and files

Where the saveRowsstep writes a run's results, and where loadRowsreads a work list back out. Every write goes out from the launcher, never from the profile's page — so a row landing in your own database is not billed to an identity's proxy.

Supabase

Needs: Project URL and service role key

Use the service_role key, not the anon key — the anon key is subject to row level security and will usually insert nothing without a policy.

Where to get a key

Postgres

Needs: Host, database, user and password

TLS is verified by default. Managed databases that present a self-signed certificate need the “require” mode, which encrypts but does not verify.

Firebase

Needs: Service account project ID, client email and private key

The service account needs the Cloud Datastore User role. Firestore is schemaless, so columns are free text.

Where to get a key

Redis

Needs: Host — password, database number and TLS where the server wants them

Rows are appended to a Redis list as JSON documents, one entry per row, and read back in arrival order. Managed Redis (Upstash, Redis Cloud) is TLS-only — pick verify-full.

Google Sheets

Needs: Service account client email and private key, plus the spreadsheet

Share the spreadsheet with the service account’s address as an Editor — a service account has no access to a file until it is shared with it, exactly like a person.

Where to get a key

Notion

Needs: Internal integration token

Open each database you want to write to and connect the integration under ••• → Connections. The token alone sees nothing.

Where to get a key

Airtable

Needs: Personal access token and the base

The token needs data.records:read, data.records:write and schema.bases:read, and access to this base.

Where to get a key

Local file

Needs: A folder on this machine

csv opens in any spreadsheet app. jsonl appends one object per line and survives a crash mid-run; json rewrites the whole array each time.

Meta Lead Ads

Needs: Page or System User access token with leads_retrieval, plus the Page id

Read-only: leads load into automations and datasets; nothing is ever written back to Meta.

Where to get a key

Point an agent at it

Create a key in the launcher, connect your client, and the tools appear in it. The API itself stays on http://127.0.0.1:39219, where only your machine can reach it.

Read the API reference See the automation steps Download Argus

Integrations

Agents over MCP

Supported clients

Claude Code

Codex

Cursor

Gemini CLI

Windsurf

VS Code

Zed

OpenClaw

Hive

Any other MCP client

Setting it up by hand

What an agent gets

Automation connectors

AI models

ChatGPT

Claude

DeepSeek

Google Gemini

Mistral

xAI Grok

OpenRouter

Together AI

Hugging Face

LM Studio

Ollama

Other

Messaging

Telegram

Slack

Discord

WhatsApp

Email (SMTP)

Databases and files

Supabase

Postgres

Firebase

Redis

Google Sheets

Notion

Airtable

Local file

Meta Lead Ads

Point an agent at it