A2A CLI

Talk to a mission — or any A2A (Agent2Agent) agent — from a terminal: read its card, send messages, stream answers.

For developers and agent-platform engineers connecting their own agents to missions.

Version 3.1.6 · Oct 19, 2026

Pick the file for your computer from the list below.

All platforms and checksums

Guide

Which tool?

  • A2A CLI (a2acli) — talk to a mission as an agent: ask it questions, give it instructions, read or stream its answers. This guide.
  • Missions CLI — run, manage and build missions from a terminal.
  • Missions API — the same from your own code. Guide: https://www.studiox-ai.com/downloads/missions-api

A2A covers conversation. Approving decisions, reading and changing records, and changing settings are in the Missions CLI and the Missions API.


What it is

A2A (Agent2Agent) is an open protocol that lets one agent discover another, send it a message and receive its answer, whole or streamed. An agent publishes an Agent Card — a JSON document that names it, says where to send messages and how to authenticate — and answers JSON-RPC 2.0 calls over HTTPS.

a2acli is a terminal client for that protocol. With it you can:

  • read any A2A agent's card and see its endpoint, capabilities, security and skills;
  • send a mission one message from a script or CI job and test the exit code;
  • hold an interactive conversation with a mission, with the answer streamed and formatted as it arrives;
  • print the raw protocol payloads to see exactly what an agent returns;
  • do the same with any other A2A agent, not only StudioX missions.

a2acli writes nothing to disk. Keys, history and conversations last only as long as the process.


Install

Download the archive for your platform from https://www.studiox-ai.com/downloads.

Archive Platform
a2acli-macos-arm64.zip macOS, Apple Silicon
a2acli-macos-x64.zip macOS, Intel
a2acli-windows-x64.zip Windows 64-bit (a2acli.exe)
a2acli-linux-x64.tar.gz Linux 64-bit

Each archive holds one binary and an INSTALL.txt. The binary is self-contained: the runtime is compiled into it, so the machine needs no Node.js and there is no install step beyond putting the file on your PATH.

Check the download

The binaries are not code-signed. Compare the archive's SHA-256 with the value published on the downloads page before you unpack it.

shasum -a 256 a2acli-macos-arm64.zip          # macOS
sha256sum a2acli-linux-x64.tar.gz             # Linux
Get-FileHash .\a2acli-windows-x64.zip -Algorithm SHA256   # Windows

A different value means the file is not the one published; do not run it.

macOS

unzip a2acli-macos-arm64.zip                  # or a2acli-macos-x64.zip on Intel
xattr -d com.apple.quarantine a2acli          # clear the Gatekeeper quarantine flag
chmod +x a2acli
sudo mv a2acli /usr/local/bin/                # or: mv a2acli ~/.local/bin/

Because the binary is unsigned, Gatekeeper blocks a downloaded copy with an "unidentified developer" message. The xattr line removes the quarantine flag so it runs. If you skip it, open the file once with right-click → Open and confirm.

Windows

  1. Unzip a2acli-windows-x64.zip.
  2. Move a2acli.exe into a folder that is on your PATH, or add its folder to PATH (Settings → System → About → Advanced system settings → Environment Variables).
  3. On first run, SmartScreen may show "Windows protected your PC". Choose More info → Run anyway.

In the examples below, type a2acli.exe or a2acli — both work from PowerShell and Command Prompt once the file is on PATH.

Linux

tar -xzf a2acli-linux-x64.tar.gz
chmod +x a2acli
sudo mv a2acli /usr/local/bin/                # or: mv a2acli ~/.local/bin/

Confirm it runs

a2acli version
a2acli v3.1.6
StudioX · https://www.studiox-ai.com

a2acli help prints the command summary. Include the version line when you report a problem.


Connect to a mission

The mission's address

Each mission is its own A2A agent:

Address
The mission's agent https://<host>/a2a/missions/<missionId>
Its Agent Card https://<host>/a2a/missions/<missionId>/.well-known/agent-card.json

<host> is the host you open Missions on, for example studiox.example.com. <missionId> is the id in the mission's address in Missions (…/missions/<missionId>).

You give a2acli the mission's address. It finds the card itself (see How the card is found).

The mission's key

A mission is called with that mission's key, sent as Authorization: Bearer <key>. The key lets the holder converse with that one mission and nothing else.

A business administrator, or the person who created the mission, makes the key in Missions:

  1. Open the mission.
  2. In its map, open the API channel.
  3. Press Make a key (or Make a new key) and copy it. It is shown once and cannot be shown again.

Making a new key stops the old one at once. Every script, CI job and agent that holds the old key starts receiving Unauthorized answers until it is given the new one. Plan a rotation as: make the new key, update every place that holds it, then confirm each one with a2acli send.

Keep the key out of your command history and code

Pass the key from an environment variable rather than typing it into a command line, where it lands in shell history and in the process list.

export MISSION_KEY='…'                        # or load it from your secret manager
a2acli send https://studiox.example.com/a2a/missions/<missionId> "hello" --bearer "$MISSION_KEY"
  • CI: store the key as a masked secret variable and reference it as $MISSION_KEY.
  • Agent platforms: store it in the platform's secret store, not in its configuration files.
  • Interactive use: omit --bearer and let a2acli prompt for the key (see Interactive session). A key typed at the prompt is kept out of the ↑ history and never written to disk.

Read the card

a2acli card https://studiox.example.com/a2a/missions/<missionId> --bearer "$MISSION_KEY"

Without the key, the card is still returned, but its name is the mission id. This is real output from the public gateway with a made-up mission id and no key:

00000000-0000-0000-0000-000000000000
  A mission exposed over the A2A protocol. Send a message and get a response (streaming supported).

  endpoint     https://www.studiox-ai.com/a2a/missions/00000000-0000-0000-0000-000000000000
  transport    JSONRPC
  version      dev
  protocol     A2A 0.3.0
  provider     StudioX
  capabilities streaming
  security     missionKey

  Skills
  • Converse — Send a message to this mission and get a response.

  card: https://www.studiox-ai.com/a2a/missions/00000000-0000-0000-0000-000000000000/.well-known/agent-card.json
Line Card field What it tells you
first line name The mission's name when you sent its key; the mission id when you did not. (unnamed agent) when the card has no name.
second line description The agent's own description.
endpoint url Where a2acli sends messages. For a mission, the mission's address.
transport preferredTransport The protocol binding; JSONRPC for missions.
version version The version string the agent reports for itself.
protocol protocolVersion The A2A protocol version the card follows.
provider provider.organization Who operates the agent.
capabilities capabilities streaming means the agent answers message/stream; push and history are other A2A capabilities. none advertised when the card lists none.
security securitySchemes The names of the authentication schemes the card declares. A mission declares missionKey, a bearer token. none / public when there are none.
Skills skills What the agent offers. A mission offers one skill, Converse: send a message, get a response.
card: — The URL the card was actually read from.

a2acli card prints a fixed summary. To see the whole JSON document, fetch the card: URL with curl.

How the card is found

Given a URL, a2acli tries these in order and uses the first that returns an Agent Card:

  1. the URL itself, if it ends in .json (for example a direct …/agent-card.json link);
  2. <url>/.well-known/agent-card.json, then <url>/.well-known/agent.json (the older A2A 0.2 name);
  3. the host's own card, <origin>/.well-known/agent-card.json, then <origin>/.well-known/agent.json.

So a mission's address finds the mission's own card, even on a host that serves other agents. The card: line shows which card was used.

Your key goes only to the host you typed. If the card sends messages to a different host, a2acli stops and sends nothing:

The agent card at https://studiox.example.com sends messages to https://other.example.net, a different host. Your key was not sent.
  If you trust https://other.example.net, connect to it directly, or run again with --trust-card-host.

A redirect to another host stops the same way, so the key is never carried there.


Ask and stream

One message

a2acli send https://studiox.example.com/a2a/missions/<missionId> "Which orders are past their ship date?" --bearer "$MISSION_KEY"

The answer prints on one line prefixed by the agent's name and ▸, with Markdown rendered for the terminal. A mission can take from seconds to a few minutes to answer; a2acli sets no timeout of its own and waits for it.

Everything after the URL that is not a flag is joined into the message, but quote the message anyway so your shell does not expand *, ? or $ in it. A word that starts with -- is read as a flag, not as part of the message.

Streaming. When the card advertises streaming (missions do), a2acli uses message/stream and the answer arrives as Server-Sent Events. Otherwise it uses message/send and the answer prints when complete. Override for one command:

Flag Method used
--stream message/stream — only if the card advertises streaming; otherwise message/send regardless
--no-stream message/send

In a terminal, a streamed answer is rendered line by line as each line completes. When output is piped or redirected, or with --raw, the answer is collected and printed once at the end. Colour is turned off when output is not a terminal or when NO_COLOR is set.

Structured parameters. --data '<json>' attaches a JSON object to the message as an A2A DataPart, beside the text. It must be a JSON object; anything else stops the command with an error rather than sending the message without it.

a2acli send https://studiox.example.com/a2a/missions/<missionId> "Summarise today's escalations." \
  --bearer "$MISSION_KEY" --data '{"responseStyle":"concise"}'

a2acli sends the object as given. Whether the agent reads a given key is up to the agent.

Interactive session

Pass the address to open a session:

a2acli https://studiox.example.com/a2a/missions/<missionId> --bearer "$MISSION_KEY"

a2acli chat <url> is the same command written out. a2acli with no arguments opens the session unconnected; connect from inside with /connect <url>.

a2acli v3.1.6 — A2A (Agent2Agent) protocol client
StudioX · https://www.studiox-ai.com
Not connected. Type /connect <url> to attach to an agent, or /help.
Type / at any time to see commands.

connecting to https://studiox.example.com/a2a/missions/<missionId> …
● connected  Order Exceptions  (streaming)
A mission exposed over the A2A protocol. Send a message and get a response (streaming supported).
→ https://studiox.example.com/a2a/missions/<missionId>
Type a message to chat, or /help for commands.

● Order Exceptions › Which orders are past their ship date?
Order Exceptions ▸ …the mission's answer…

The prompt shows the agent you are connected to. Plain text is sent to it; a line starting with / is a command.

Without --bearer, a2acli reads the card first, sees that the mission requires a bearer key, and asks for it:

This agent authenticates with the mission's API key.
paste the mission's API key › 

The key is shown as you type, is not recorded in the ↑ history and is never written to disk. Pressing Enter with nothing typed ends the attempt with Authentication required to use this agent.

a2acli does not test a mission's key when it connects — a test message would start a real mission run. A wrong or replaced key is accepted at connect and shows up on your first message as Unauthorized followed by · task failed. Type /auth to enter the right key; a2acli reconnects with it.

Commands inside the session

Type / to open the command menu. Keep typing to filter it (/co → /connect); ↑/↓ move the highlight, Tab completes the highlighted command and adds a space for its arguments, Enter runs it, Esc closes the menu. Enter runs the highlighted command with no arguments, so for a command that takes one (/connect, /stream, /raw, /data), press Tab or type a space before the argument.

The menu shows only the commands that apply: before you connect, /connect, /about, /help, /clear and /quit; once connected, all of them.

Command Needs a connection What it does
/connect <url> [flags] no Connect to an agent. Takes the same flags as the command line: --bearer, --api-key, --stream, --no-stream, --raw, --data. On success it replaces the current connection; on failure the current one is kept.
/auth (also /key, /login) yes Enter or replace the key for the current agent, then reconnect. Press Enter on an empty line to keep the current key.
/disconnect yes Drop the current agent and discard the conversation.
/card yes Print the connected agent's card, as a2acli card does.
/skills yes List the agent's skills with descriptions and up to three example prompts each.
/info yes Show the agent, endpoint, streaming setting, the method actually in use, raw echo, parameters, and the current context id and task id.
/stream on|off yes on uses message/stream, off uses message/send. If the agent does not advertise streaming, on is noted and replies still use message/send.
/raw on|off yes Print the raw JSON-RPC results before each reply.
/data [json|clear] yes With no argument, print the parameters sent with each message. A JSON object is merged into them. clear removes them.
/new yes Start a new conversation with the same agent (clears the context id and task id).
/about no Version and StudioX contact details.
/support no How to reach StudioX support, and what to include in a report.
/help [command] no List the commands available now; with a name, print its usage, flags and examples (/help connect).
/clear no Clear the screen. The connection and conversation are kept.
/quit (also /exit, /q) no Exit.

/auth reconnects with a fresh session. The conversation starts over, and streaming, raw echo and /data parameters return to their defaults; set them again if you need them.

Line editing

Key Action
← / → Move the cursor
Home or Ctrl-A / End or Ctrl-E Start / end of the line
Backspace / Delete Delete before / at the cursor
Ctrl-U Delete from the cursor to the start of the line
Ctrl-K Delete from the cursor to the end of the line
Ctrl-W Delete the word before the cursor
↑ / ↓ Move through the menu when it is open; otherwise step through this session's history
Tab Complete the highlighted command
Esc Close the command menu
Ctrl-L Clear the screen
Ctrl-C Clear the line; on an empty line, press it twice to exit
Ctrl-D Delete at the cursor; on an empty line, exit

Pasted text with line breaks is joined into one line. While a reply is on its way the editor is not active; Ctrl-C at that point ends a2acli.

If standard input is not a terminal (piped input), a2acli reads one line at a time with no menu or editing keys. For scripts, use a2acli send.

How a conversation is threaded

What the client does on each message:

  • Context id. Each reply's contextId is kept and sent with your next message, so the agent can treat consecutive messages as one conversation. A StudioX mission does: it answers a follow-up in the light of the earlier messages ("What code word did I just give you?" is answered). A mission continues only conversations it started for you; an unknown contextId starts a new one.
  • Task id. When a reply's task ends in input-required or auth-required, a2acli keeps that task's id and sends it with your next message, so your reply continues the same task. It prints · agent is waiting for your input (input-required) — reply to continue. When a task reaches a final state (completed, failed, canceled, rejected), the task id is cleared and the next message starts a new task in the same context.
  • Reset. /new clears both ids. /disconnect, /connect and /auth start a new session with neither.
  • One-shot. Each a2acli send is a separate process and starts with no context id. Separate send commands are not threaded together.

/info shows the current context id and task id.


Scripts and CI

One message, one exit code

if ! answer=$(a2acli send "$MISSION_URL" "Which orders are past their ship date?" --bearer "$MISSION_KEY" --no-stream); then
  echo "mission call failed: $answer" >&2
  exit 1
fi
echo "$answer"

The reply and its status notes (· task failed) go to standard output; errors and warnings go to standard error. When output is not a terminal there is no colour.

Exit codes

a2acli send exits:

Code When
0 The agent answered and the task ended completed, is waiting for input (input-required), or the agent replied with a plain message rather than a task
1 The task ended failed, rejected, canceled or auth-required
1 The card says authentication is required and no key was given (Authentication failed (HTTP 401). Pass --bearer <token> or --api-key <HEADER:VALUE>.)
1 An HTTP 401 or 403, a JSON-RPC error (RPC error <code>: <message>), a network failure, or no Agent Card at the address
1 A usage error: missing URL or message, or --data that is not a JSON object

A wrong, missing or replaced mission key does not arrive as an HTTP error. The mission returns HTTP 200 with a task whose state is failed and whose text is Unauthorized. a2acli prints it and exits 1:

$ a2acli send https://www.studiox-ai.com/a2a/missions/00000000-0000-0000-0000-000000000000 hello --bearer fake
00000000-0000-0000-0000-000000000000 ▸ Unauthorized
  · task failed
$ echo $?
1

Check the exit code on every call; the printed text alone does not distinguish an answer from a refusal.

a2acli card exits 0 when it printed a card and 1 when it could not fetch one. An unrecognised flag prints note: --<flag> is not used by <command> — ignored on standard error and does not change the exit code.

Raw protocol payloads

--raw prints what the agent returned before the formatted reply:

  • with message/send (--no-stream), the whole JSON-RPC result — the task, with its status and artifacts — pretty-printed;
  • with message/stream, each Server-Sent Event's result on its own line (task, status-update, artifact-update, message).

The formatted <name> ▸ … line still follows. --raw shows responses, not the requests a2acli sent. For a mission, the answer text is in the task's artifacts[].parts[].text, and status.state is the outcome.

Authentication flags

Flag Sends
--bearer <token> Authorization: Bearer <token>
--api-key <HEADER:VALUE> <HEADER>: <VALUE>
--api-key <VALUE> X-API-Key: <VALUE>, with a note on standard error naming the header used

A mission takes --bearer. --api-key is for agents whose card declares an API-key header. Repeat --api-key to send several headers, and combine it with --bearer when an agent needs more than one credential; all are sent on every request, including the card fetch.

Every flag also accepts the --flag=value form, which keeps a value that starts with -- intact.

TLS certificates

a2acli checks the server's TLS certificate on every request. If the check fails — a self-signed certificate, a chain missing an intermediate, an internal certificate authority your computer doesn't know, an expired certificate or a host-name mismatch — it stops and says why:

The certificate of https://studiox.example.com could not be verified (CERT_HAS_EXPIRED: certificate has expired).
  If this server uses your organisation's own certificate authority, point a2acli at it and keep checking on:
    NODE_EXTRA_CA_CERTS=/path/to/your-ca.pem a2acli …
  Or, if you trust this server, run again with --insecure (certificate checks off for that run).

Your two ways on:

  • Your organisation's certificate authority — set NODE_EXTRA_CA_CERTS to its PEM file. Certificates stay checked; a2acli now trusts your authority as well. This is the one to use for an internal deployment.
  • --insecure (or -k) — no certificate checks for that run, for every request, with a warning printed first. Use it only for a server you trust on a network you trust; your key travels without the certificate check.

Other A2A agents

a2acli speaks plain A2A and works with any agent that publishes an Agent Card and answers JSON-RPC 2.0 message/send (and message/stream, if it advertises streaming). Point it at the agent's base URL, its origin, or its card URL:

a2acli card https://agent.example.com
a2acli https://agent.example.com

It reads the JSON-RPC endpoint from the card's url, or from a JSONRPC entry in additionalInterfaces, and falls back to the URL you gave. Task states are accepted in both the JSON-RPC spelling (completed) and the protocol-buffer spelling (TASK_STATE_COMPLETED). A reply that is a plain message rather than a task is printed as the answer.

How the interactive session asks for credentials

When you connect without --bearer or --api-key, a2acli reads the card's securitySchemes and security:

Card declares What a2acli asks for
http with scheme: bearer A bearer token, labelled with the scheme's description if it has one
apiKey A value for the header the scheme names (X-API-Key if it names none). A scheme located in a query or cookie is noted; a2acli sends it as a header regardless.
oauth2 or openIdConnect An access token you already hold, sent as a bearer token. a2acli does not run an OAuth sign-in.
several schemes Each one in turn; a blank answer skips that one, and all answers are sent together
schemes listed, security empty The same prompts, marked (Enter to skip); you can connect without credentials
no schemes, card readable without a key Nothing; you connect. If a message is then refused with 401 or 403, a2acli prints authentication required — type /auth, and /auth asks which kind ([1] bearer token [2] api-key header) and, for an API key, the header name
card itself refused without a key Nothing; the connection fails with Failed to connect: …. Connect again with /connect <url> --bearer … or --api-key …

A rejected key at connect (a 401 or 403 on the card) asks again, up to three attempts. For an agent other than a mission whose card requires authentication, a2acli also sends a test hello after connecting and asks again if the agent answers auth-required or 401/403; the test answer is not shown. In a2acli send there are no prompts — pass the flags.


Troubleshooting

What you see Cause What to do
<name> ▸ Unauthorized then · task failed; send exits 1 No key, a wrong key, or an old key after a new one was made. The mission reports it as a failed task over HTTP 200, not as an HTTP error. Send the mission's current key with --bearer "$MISSION_KEY". In a session, type /auth. If the key was replaced, get the new one from whoever made it.
Authentication failed (HTTP 401). Pass --bearer <token> or --api-key <HEADER:VALUE>. send without a key to an agent whose card requires one Add --bearer.
The card's name is the mission id The card was fetched without the key Expected. Pass --bearer to see the mission's name.
The agent card at … sends messages to …, a different host. Your key was not sent. The card found names an endpoint on another host Check the address you gave is the mission's. If the other host is yours, connect to it directly or add --trust-card-host.
… redirects to …, a different host; not followed with your key. The agent's address redirects to another host Connect to the address it redirects to, if that host is yours.
Could not fetch an Agent Card from "<url>": GET … → HTTP 404 Wrong mission id, or /a2a is not routed on this host Check the id against the mission's address in Missions. Check that https://<host>/a2a/api/version answers.
RPC error -32601: Method not found (or stream HTTP 400: … with streaming on) The agent does not offer the method a2acli called If streaming was on, retry with --no-stream. A mission offers message/send and message/stream.
The streamed answer appears all at once at the end, or stops partway A proxy between you and /a2a is buffering or timing out text/event-stream Use --no-stream (or /stream off). Ask whoever runs the proxy to pass /a2a through unbuffered and allow long reads.
The certificate of … could not be verified (…) The server's certificate fails the check: an internal certificate authority, a missing intermediate, expired, or the wrong host name Set NODE_EXTRA_CA_CERTS to your organisation's CA file, or have the server's certificate chain fixed. --insecure only for a server you trust. See TLS certificates.
· task failed with text other than Unauthorized The mission could not answer (for example, it is paused) Read the text; check the mission in Missions.
· agent is waiting for your input (input-required) The agent asked a question Reply in the session; your reply continues the same task. In send, this exits 0 and the next send does not continue it — use a session.
note: --<flag> is not used by <command> — ignored A flag the command does not take, often a typo Check the command reference.
macOS: "cannot be opened because the developer cannot be verified" Gatekeeper quarantine on an unsigned download xattr -d com.apple.quarantine a2acli, or right-click → Open once.
Windows: "Windows protected your PC" SmartScreen on an unsigned download More info → Run anyway.
a2acli: command not found / 'a2acli' is not recognized The binary's folder is not on PATH Move it to a folder on PATH, or run it by its full path.

When you contact StudioX (https://www.studiox-ai.com, or a2acli about), include the output of a2acli version, the address you called, and, if you can, the output of the same command with --raw --no-stream. Remove the key before you send it.


Command reference

Commands

Command What it does
a2acli Start the interactive session, not connected
a2acli <url> [flags] Connect to the agent at <url> and start the session
a2acli chat [url] [flags] Same as above; with no URL, start not connected
a2acli send <url> <message> [flags] Send one message, print the reply, exit with a status code
a2acli card <url> [auth flags] Fetch and print the Agent Card
a2acli version (also --version, -v) Print the version
a2acli help (also --help, -h) Print the command summary
a2acli about (also a2acli support) Version and StudioX contact details

Flags

Flag Used by Effect
--bearer <token> <url>, chat, send, card, /connect Send Authorization: Bearer <token>
--api-key <HEADER:VALUE> <url>, chat, send, card, /connect Send a custom header; without HEADER:, the header is X-API-Key. Repeatable.
--stream <url>, chat, send, /connect Use message/stream (when the card advertises streaming)
--no-stream <url>, chat, send, /connect Use message/send
--raw <url>, chat, send, /connect Print the raw JSON-RPC results
--data '<json>' <url>, chat, send, /connect Attach a JSON object to each message as a DataPart
--insecure, -k all No certificate checks for this run (prints a warning). Prefer NODE_EXTRA_CA_CERTS
--trust-card-host <url>, chat, send, /connect Send the key to the host the card names when it is not the host you typed (prints a warning)

With neither --stream nor --no-stream, streaming follows the card's capabilities.streaming. If both are given, --stream wins.

Session commands

Command Aliases Effect
/connect <url> [flags] Connect to an agent
/auth /key, /login Enter or replace the key, then reconnect
/disconnect Drop the current agent
/card Print the agent's card
/skills List the agent's skills
/info Show connection and conversation details
/stream on|off Choose message/stream or message/send
/raw on|off Print raw JSON-RPC results
/data [json|clear] Show, merge or clear the DataPart parameters
/new Start a new conversation
/about Version and contact details
/support How to reach StudioX support
/help [command] /h List commands, or explain one
/clear Clear the screen
/quit /exit, /q Exit

Version history

3.1.6 · Oct 19, 2026

Your key goes only to the host you typed: if an agent card names another host, or a request is redirected to one, a2acli stops and sends nothing. --trust-card-host allows it.

3.1.5 · Oct 16, 2026 · Maintained
  • A mission's own agent card is found first; a card that sends messages to another host warns before your key is sent there.
  • An unverifiable certificate stops the connection with the reason: use NODE_EXTRA_CA_CERTS for your organisation's certificate authority, or --insecure (with a warning).
  • send exits 1 when the task fails.
  • Every earlier version is out of support: update to 3.1.5.
2.x · Apr 1, 2026 · End of support

The A2A CLI 2 line, released April 2026. End of support — update to 3.1.5.

1.x · Nov 1, 2025 · End of support

The first A2A CLI line, released November 2025. End of support — update to 3.1.5.

All platforms

PlatformFileSizeSHA-256
Linux x64a2acli-linux-x64.tar.gz34.3 MB5f20f199a6d1829d8cd036c10e461a374a541a03a2822579c1cedc214029cc7d
macOS (Apple silicon)a2acli-macos-arm64.zip22.9 MB64b273d3d2e8bb8d26ba0da28191cbd896027385b472fee4b9d945ead8e20f9b
macOS (Intel)a2acli-macos-x64.zip25.3 MBc0d3b183a649d7d5d6311dd55554acd22ad68173da86e306b9bdf353e2a8c105
Windows x64a2acli-windows-x64.zip36.6 MB986fef4df759c2153155e557b78ad8c0f51ecb478155b605e4b4df55fe9eee61

SHA256SUMS

Check the file is ours

Compare the file's SHA-256 with the one listed for it before you run it.

# macOS / Linux
shasum -a 256 <file>

# Windows (PowerShell)
Get-FileHash <file> -Algorithm SHA256

Related

  • Missions CLI — Run, manage and build missions from a terminal or a script: ask a mission, approve what's waiting, run watchers, change records and settings, install and upgrade missions.
  • Missions API — Run, manage and build missions from your own code over HTTP: tokens, every endpoint, errors, jobs, worked examples.