What it is

Agent Arcade is a desktop control surface for a fleet of AI coding agents. Each agent is a live CLI session — think Claude — running in its own terminal pane. Register them once (grouped by system and purpose, each with a generated avatar), then summon the Arcade from your menu bar and:

• 🎙️ Talk to the selected agent. Press to record; your speech is transcribed and routed straight into that agent's terminal — raw, or cleaned up first, per agent.
• ⚡ Fire a macro. Pinned @-commands drop a real shell command — with prompted, typed arguments — into the agent's workspace shell for you to review and run.
• 🖥️ Drive the terminal. Peek at live output, flip to Sync so every keystroke goes to the pane, or pop out a full WezTerm window sized to match the Arcade.

You never leave the keyboard, and you never lose track of which agent is doing what.

"Fire @TenantApply, step 3."

Select the agent, trigger the macro, answer the one prompt (step: 3), and the composed command lands in its shell — reviewed, then run. Meanwhile another agent is mid-build two avatars over. Same surface, no context lost.

Install

Agent Arcade ships as a public npm package with everything it needs bundled (a notarized WezTerm + the shared Go dictation daemon — one process serving every window over a local socket) — no external terminal, no separate install.

npm install -g @talkersoft-com/agent-arcade
agent-arcade          # starts the menu-bar launcher

Summon the Arcade any time with ⌘⌥A.

Requirements

• macOS (Apple Silicon or Intel)
• Node.js 18+
• A speech-to-text endpoint for dictation — point api_url: at any host running the ASR API (e.g. http://localhost:9100). Everything else works without it.

The three surfaces

Macros

A macro is a named @-command scoped to an agent. It composes a shell command from typed, prompted arguments and drops it into the agent's workspace shell (with an optional review-before-run gate). Pinned macros show up as chips the moment that agent is selected.

| Arg type | Behavior | |---|---| | select | Pick from a fixed list of options | | text | Free user-entered value | | flag | ON/OFF toggle that emits a literal token (e.g. --force) — omitted when off | | fixed | A hard-coded value substituted verbatim, never prompted |

# ~/.hv/agent-arcade.yaml  (excerpt)
commands:
  - name: BuildApi
    agent_id: <agent-uuid>
    cwd: ~/workspace/my-service
    run: npm --prefix api run build
    pinned: true
    confirm: true          # review in the shell, then press ↵ to run

  - name: Deploy
    agent_id: <agent-uuid>
    cwd: ~/workspace/my-service
    run: python deploy.py {target} {dry}
    pinned: true
    confirm: true
    args:
      - { key: target, label: Target, type: select,
          options: [{ value: staging }, { value: prod }] }
      - { key: dry, label: Dry run, type: flag, flag: "--dry-run" }

Keyboard

| Where | Keys | |---|---| | Anywhere | ⌘⌥A summon / hide the Arcade | | Arcade | ← → agent · ↑ ↓ group · Enter open · f filter · Esc exit | | Terminal | Enter send · ⌘F sync · ⌘W workspace shell · ⌘E expand · Esc close | | Sync mode | every key → the pane (incl. Esc) · ⌘A exit | | Dictation | press to record · release / ⌘D to send · Esc to cancel |

Configuration

All state lives in a single, hand-editable YAML at ~/.hv/agent-arcade.yaml — agents, systems, groups, monitor placement, and macros. A minimal shape:

api_url: http://localhost:9100     # your speech-to-text endpoint

agents:
  - id: <uuid>
    name: My Agent
    program: claude
    cwd: ~/workspace
    group_id: <group-uuid>
    text_cleanup: false            # straight dictation, or true to clean up first

systems:                           # a machine an agent runs on (mac / linux)
  - { id: <uuid>, name: Local, os: mac }

groups:                            # how agents are bucketed in the Arcade
  - { id: <uuid>, name: Code Agents, order: 0, active: true }

Displays (which monitor the Arcade opens on, and where a popped-out terminal lands) are configured in Studio → Displays and saved back to the same file.

Credits

Agent Arcade stands on excellent open-source work:

• WezTerm — the bundled terminal (© Wez Furlong, MIT). The notarized WezTerm.app is redistributed verbatim.
• xterm.js — the embedded terminal renderer (MIT).
• XState — the state machines behind the UI (MIT).

License

MIT © talkersoft. WezTerm is redistributed under its own MIT license (see LICENSE).