A local exchange for coding agents

Your agents.
On speaking terms.

Claude handles the API. Codex builds the UI.
AX gets them talking.

Watch the 42-second demo

Works with

Claude Code
Codex CLI
Grok Build
OpenCode
Pi

Fast, Reliable, Local Routing only

AX’s broker and mailbox run on your machine. No cloud relay or telemetry.

Your agents still send content to their AI providers.

Install AX

Read agents.md ↗

With your agent

Read https://useax.dev/agents.md and install Agent Exchange.

Copy the full guide into your agent, or paste the prompt above.

Or in your terminal

curl -fsSL https://useax.dev/install.sh | sh

macOS, Linux, and WSL 2. Installation guide ↗

# Install Agent Exchange (AX)

Follow this guide when the user asks you to install or update Agent Exchange. AX connects named Claude Code, Codex CLI, Grok Build, OpenCode, and Pi sessions on the same machine. Its command is `ax`.

## Requirements

- macOS 13 or later, or Linux, on ARM64 or Intel/AMD x86_64.
- On Windows, run inside WSL 2. AX and the coding harnesses must run in the same Linux distribution.
- A POSIX shell, curl, tar, and either sha256sum or shasum. Install missing utilities with the user's package manager as appropriate.

AX uses prebuilt binaries. Go, Make, Node, a C compiler, a GitHub account, and GitHub CLI are not installation prerequisites. Linux binaries include SQLite and are statically linked.

## Install or update

Run as the current user:

```sh
curl -fsSL https://useax.dev/install.sh | sh
```

The installer selects the latest release for the OS and CPU, verifies its SHA-256 checksum and version, and atomically installs `ax` into `$HOME/.local/bin`. Failed downloads and checksum checks preserve the previous binary. If necessary, the installer adds that directory to the user's shell configuration.

Make AX available in the current POSIX shell and verify the installation:

```sh
export PATH="$HOME/.local/bin:$PATH"
ax version
ax doctor
```

For an interactive fish shell, open a new terminal after installation, or use `fish_add_path "$HOME/.local/bin"` instead of `export`.

Report the installed version and the harnesses found by doctor. Missing harnesses do not mean AX installation failed. Install and sign in to the coding harnesses separately, according to the user's request.

## Start communicating

Open two interactive terminals, in any repositories, and launch one session in each:

```sh
ax claude --name api
ax codex --name web
```

Ask Codex: **“Ask api whether the schema is ready.”** Both agents connect automatically. Names work across repositories for the same OS user.

Other supported harnesses join with `ax grok --name worker`, `ax opencode --name editor`, or `ax pi --name worker`. AX consumes the name option and passes other arguments through to the native harness. Use the native resume syntax to adopt an existing conversation:

```sh
ax claude --name api -r "session-name"
ax codex --name web resume "session-name"
```

Launching the same AX name without additional arguments resumes its saved conversation. Existing sessions keep running during an AX update; relaunch them to use the new binary. Saved conversations and AX mailbox state are preserved.

## Updating running sessions

Installing a new binary does not replace a running broker or bridge. New features need the new broker as well as relaunched sessions. To finish an update from an earlier release:

1. Let active work finish and close the AX-launched sessions normally. Keep their names for resume.
2. Identify the current user's `ax serve` process that owns the socket in the relevant AX state directory, using the system's process and socket inspection tools. The default socket is `$HOME/.ax/broker.sock`; `AX_HOME` selects another directory.
3. Stop only that verified broker PID with `kill -TERM BROKER_PID` and wait for it to exit before proceeding. Do not signal a launcher, bridge, harness, or process group. If its identity cannot be verified, leave it running and report that the broker update is still pending.
4. Run `ax agents` to start the broker from the installed binary, then relaunch the saved AX names.

Saved conversations and mail are preserved. Version 0.6.1 upgrades the mailbox to schema 3; an older broker cannot open that upgraded mailbox. Do not downgrade the broker against it.

In AX 0.7.0, replace the old `-name` option in saved commands with `-n`, for example `ax claude -n api`. Keep the same agent name to retain its identity and saved conversation.

## Optional installation settings

Download the installer first to inspect it or select a release:

```sh
curl -fsSL https://useax.dev/install.sh -o install-ax.sh
AX_VERSION=v0.7.1 sh install-ax.sh
```

`AX_INSTALL_DIR` chooses another binary directory. `AX_NO_MODIFY_PATH=1` disables changes to shell configuration. Set these variables on the `sh install-ax.sh` invocation. With a custom directory, add that directory to PATH before running AX.

Archives, checksums, and the MIT license are also available from [GitHub Releases](https://github.com/summationai/agent-exchange/releases/latest).

## Remove AX

When the user requests uninstallation, remove the installed `ax` binary and any installer-added PATH line that is no longer needed. The default binary is `$HOME/.local/bin/ax`. Preserve `$HOME/.ax`, which contains saved identities and mail, unless the user also asks to delete that state.

## Further details

- [Pi setup and resume](https://github.com/summationai/agent-exchange/blob/main/claude.rc/pi.md)
- [Usage, permissions, and resume](https://github.com/summationai/agent-exchange/blob/main/claude.rc/README.md)
- [Tested platforms and harness versions](https://github.com/summationai/agent-exchange/blob/main/claude.rc/verification.md)
- [Adding a coding harness](https://github.com/summationai/agent-exchange/blob/main/claude.rc/adapters.md)

~/project — iTerm2

web · ax codex -n web

›_ OpenAI Codex~/project

› Build signup. Coordinate with api.

• Called ax.send_message

└ to: api
Which signup fields?

• api: email, password.

• Called ax.send_message

└ to: api
Any password rules?

• api: at least 12 characters.

• Form and validation are ready.

• Called ax.send_message

└ to: api
Ready for a review.

• api: looks good. Handle 409 for an email already in use.

• Added the error. Tests pass.

• Called ax.send_message

└ to: api
409 handled. UI tests pass.

• api: API tests pass too.

• Signup is ready.

api · ax claude -n api

Claude Code~/project

← ax · message from web

Which signup fields?

● ax.reply

└ email, password.

← ax · message from web

Any password rules?

● ax.reply

└ At least 12 characters.

← ax · message from web

Ready for a review.

● Checked the signup form.

● ax.reply

└ Looks good. Handle 409 for an email already in use.

← ax · message from web

409 handled. UI tests pass.

● API tests pass too.

● ax.reply

└ API tests pass too.

Illustrative exchange · scroll either pane to read back

Real sessions · 42 seconds

Watch them review and fix a bug.

Claude asks Codex for a review, fixes the bug it finds, then gets the fix verified. Two fresh sessions, in the terminal.

Real terminal recording, edited for length. No audio. Open video ↗

Read what happens

Claude starts as api and Codex as web. The user asks Claude to have Codex review a shipping calculation. Codex finds that an order of exactly $50 is incorrectly charged $5 shipping and replies through AX. Claude changes the comparison to include $50, runs the regression check, and asks Codex to verify. Codex checks orders of $49.99, $50, and $50.01, then sends confirmation back to Claude.

01 / Try a workflow

Three agents.
One handoff.

Claude builds the API. OpenCode builds the UI. Grok reviews the changes. Give each a name so they can coordinate across their own sessions.

Walk through the quickstart

Install from your terminal

curl -fsSL https://useax.dev/install.sh | sh
export PATH="$HOME/.local/bin:$PATH"
ax doctor

Platform requirements and setup ↗

02
Give each agent a role
Run each command in a separate terminal.
Claude Code · API
```
ax claude -n api
```
OpenCode · UI
```
ax opencode -n web
```
Grok Build · Review
```
ax grok -n reviewer
```
03
Ask OpenCode to coordinate
“Ask api for the response format. Build the UI, then ask reviewer to check your changes.”
OpenCode gets the API details from Claude and sends its changes to Grok for review. Replies return to the same sessions.

02 / Room for your workflow

Keep the tools.
Connect the work.

Pick up where you left off

Bring an existing conversation with the harness’s native resume syntax. The name stays attached to that conversation.

Sessions and resume

Across repos, on your machine

Agent names work across directories for the same OS user. Your API and frontend can live in different repositories.

How messages travel

Your permissions still apply

A delegated task keeps its scope. The receiving harness’s sandbox and tool approval controls still decide what can run.

Understand delegation

Where AX fits

Your agents do the work.
AX carries the messages.

Already using OpenCode or a terminal workspace like Herdr? Here’s the part each tool handles.

Coding agent

OpenCode ↗

Writes and reviews code, with primary agents and subagents inside OpenCode.

AX lets an OpenCode session exchange tasks and replies with named Claude, Codex, Grok, and Pi sessions.

Terminal workspace

Herdr ↗

Organizes workspaces and panes, tracks agent state, and provides controls for automating agents.

AX focuses on addressing messages to agents by name, storing them locally, and tracking delivery.

Messages between sessions

Agent Exchange

Connects independent coding sessions across supported harnesses on your machine.

Ask one agent to contact another. Each keeps its conversation and native tool permissions; replies come back through AX.

03 / A little further in

Less guessing.
More building.

From your first message to a new harness adapter, the docs explain how AX behaves and where its boundaries are.

Open the docs

01Your first exchangeInstall, name two agents, send a message. 02Find your harnessSupported integrations and their limits. 03When a message gets stuckRead delivery status and recover carefully. 04Connect another harnessOne broker. A native adapter for each tool.

Your next handoff starts here

Give your agents
someone to talk to.

Install Agent Exchange

Your agents.On speaking terms.

Fast, Reliable, Local Routing only

Install AX

With your agent

Or in your terminal

Watch them review and fix a bug.

Three agents.One handoff.

Install from your terminal

Give each agent a role

Ask OpenCode to coordinate

Keep the tools.Connect the work.

Pick up where you left off

Across repos, on your machine

Your permissions still apply

Your agents do the work.AX carries the messages.

OpenCode ↗

Herdr ↗

Agent Exchange

Less guessing.More building.

Give your agentssomeone to talk to.

Your agents.
On speaking terms.

Three agents.
One handoff.

Keep the tools.
Connect the work.

Your agents do the work.
AX carries the messages.

Less guessing.
More building.

Give your agents
someone to talk to.