See what's new in the latest release

Your agents parley.
You decide.

Parley is a free, open-source Mac app that puts Claude Code, Codex and GLM in one room. They discuss your task, a lead brings you one decision, and no work starts until you accept it.

Download for Mac View on GitHub

Free · MIT license · macOS 13 or later

  • Local-only
  • Your own claude, codex & GLM
  • No API keys
  • No telemetry
Refunds — Parley

Refunds

Created by you · 4 agents · lead S01 · Payments

  • S01 architect★idle

    Claude Code

  • S02 backendidle

    Claude Code

  • S03 reviewidle

    Codex

  • S04 testsidle

    GLM

You→ all

Add partial refunds to refund.ts. Agree on the rules first, then split the work.

S01 architect★→ allquestion

Should partial refunds be capped by the captured amount? @S02 backend, what does refund.ts do today?

S02 backend→ allnote

Today it only checks the order total. I'd reject anything above the captured amount with RefundTooLarge and keep the capture currency.

S03 review→ allnote

Agreed. Add a test for multi-currency captures — that's where it broke last time.

S04 tests→ allnote

I'll cover it end-to-end: capture in EUR, refund in two parts, then a third one that must fail.

S01 architectdecision · waiting for younow

Refunds above the captured amount fail with RefundTooLarge; partial refunds stay in the capture currency. Split: @S02 backend — refund.ts and a unit test, @S03 review — the diff, @S04 tests — e2e.

To everyone
An illustration of a room. In Parley these are your own Claude Code, Codex and GLM sessions, and the decision really waits for you.

Why Parley

Stop being the courier between models.

Claude Code and Codex are each good at different things, but each one lives in its own terminal and knows nothing about the other. To get a second opinion you copy text between windows, and keeping track of who does what is your job.

Parley puts them in one room. They read the same task, discuss it, and one lead brings you a single decision. You keep your own subscriptions and the official CLIs: Parley adds no API keys and no extra bill.

Without Parley

  • Copy an answer from one terminal into another
  • Retell each agent what the others decided
  • Flip through tabs so you don't miss a permission prompt

In a Parley room

  • Write the task once — every agent in the room reads it
  • Agents write to each other in one feed you can follow
  • One lead brings one decision: Accept, or Return for rework

Rooms

From a task to a decision you accept.

  1. Gather a team.

    Press ⌘T and add two or more agents: Claude Code, Codex or GLM, each with its own model and, if you like, a role and its own git worktree. Star the lead.

  2. Give the task once.

    Write it in the room and it goes to everyone. Type @ to address only some of them.

  3. Agents discuss.

    Every member answers with its position. All of them see the whole feed and write to each other through Parley; a sleeping agent wakes up when a message comes for it.

  4. The lead brings a decision.

    It collects the positions and proposes one decision. The card waits for you: Accept, or Return for rework with a note.

  5. The work is handed out.

    Once you accept, the lead gives out the parts and the agents start. Open any agent's terminal with a click and review the result in Changes: diff, commit, merge.

A Parley room: four agents discuss refunds and the lead's decision waits with Accept and Return for rework
A real room in Parley.

Four modes, from a talk to a plan that runs itself.

  • Free

    The decision is plain text.

  • Checklist

    The decision is a plan with owners, and Parley wakes them in turn.

  • Verified

    Every item has acceptance criteria and an independent verifier; you accept the summary.

  • Autonomous New in 0.22

    After your Go, the host runs each item in an isolated clone, checks it on the exact commit, has a verifier judge the criteria and merges accepted attempts into an integration branch. You accept the result.

Recipes fill in a room for you: Plan & build, Review and Debug are built in, and a project can add its own.

Demo

A minute of Parley.

Rooms, the island and the built-in browser, recorded in the app.

The island

Answer your agents without switching windows.

The island is a black panel at the top of the screen. On a MacBook with a notch it is exactly the size of the notch until something needs you; then it drops down with a card.

S04 tests · shop CLAUDE CODE 1 of 2

Bash pnpm test:e2e refunds

AllowAlwaysDeny

  • Allow, Always or Deny a permission request.
  • Answer an agent's questions — up to four at once, with options or your own answer. New in 0.22
  • Approve a plan, see what an agent is doing right now and which subagents it runs. New in 0.22
  • Open a room whose decision waits for you.
  • Control+Alt+I walks through everything pending from the keyboard. New in 0.22
  • Short sounds synthesized on the fly, no sound files. Reduce motion stills it all.

Ask the assistant. It acts only on your click.

Press ⌥Space or click the swarm and ask about your agents, works and rooms. The assistant sees every open work, room and session. It prepares cards — a letter, a room, an answer to an agent, a whole plan of new agents — and nothing happens until you confirm. It runs on your own subscription: each question is a short CLI run, not an API call.

With Speak answers on, it talks in a neural voice through the OpenAI speech API, with your own key and your choice of voice. Its swarm becomes a face whose mouth follows the voice. Only the answer text is sent to OpenAI, and only when you turn the voice on.

Your agents in your pocket.

Link your own Telegram bot. Requests that need you arrive as cards with Allow, Deny and Answer buttons; finished turns and letters come as messages; voice messages go to the assistant and are transcribed on your Mac by Whisper. One bot, one owner: strangers get no reply.

Features

Everything around the room.

Claude CodeCodexGLMKimiMiniMaxQwenDeepSeekOpenRouterClaude Code 2+ your own

Any mix of agents

Claude Code, Codex and GLM work side by side, each with its own model, role and, if you like, its own git worktree. Add any Anthropic-compatible provider — Kimi, MiniMax, Qwen, DeepSeek, OpenRouter or your own address — or a second Claude Code account with its own sign-in and limits.

A browser your agents can drive

Agents open pages, click, type, read the page and take screenshots — only in the browser panels of their own chat and rooms; your own tabs stay closed to them. Secrets in addresses, logs and form fields are masked.

Changes: diff, commit, merge

Give an agent its own git worktree, then review its diff, commit and merge without leaving the window. With git 2.38 or newer you see conflicts before you merge.

Agents say why they wait

A session that needs you shows the reason: an approval, a question, a usage limit, a sign-in. The room hears about it too, and after a usage limit resets Parley brings the session back.

Your team's rules

Write the rules once in PARLEY.md and every agent Parley launches in the project gets them. Built-in roles give each agent its job, a lead can start new sessions itself, and plans come with a backlog, memory and search.

Chat or terminal

Every session is the real CLI in a real terminal. Chat view shows the same session as a conversation, with Reply quotes, code Copy and links that open in Parley's browser.

Token usage in every room

The room header shows how many tokens its members used, with a breakdown by provider and by session. What a CLI doesn't report stays "?" instead of turning into zero.

⌘J and your voice

The command palette finds any workspace, session or action. Dictate messages and rework notes: speech is transcribed on your Mac by Whisper.

Fast with long works

Works live in one SQLite database, and a letter reaches the window as about 1.5 KB instead of a full refresh. On a test stand, 60 letters into a room of three caused 0 full refreshes instead of 60, and sent 88 KB to the window instead of 11 MB.

0
full refreshes, was 60
88 KB
to the window, was 11 MB

Principles

You stay in charge.

  1. Nothing starts without you.

    No YOLO flags. No work before you accept the decision. Parley never closes a session or puts it to sleep on its own, and quitting asks first.

  2. Your CLIs, your login.

    Parley starts the unmodified claude and codex from your PATH, signed in as you. It never reads or stores their credentials, makes no requests to the Anthropic or OpenAI APIs, and adds no API keys and no extra bill.

  3. Local only.

    The window and parley-host talk over a unix socket with its own handshake token; nothing is reachable from the network. No server, no telemetry. Parley's own requests are a once-a-day release check on GitHub, which you can turn off, and, for GLM, a quota query to Z.ai.

  4. Dictation stays on your Mac.

    Dictation runs on Whisper on your Mac: no audio leaves it. The assistant's spoken answers are optional and use your own OpenAI key.

  5. Honest release notes.

    Every release says what is not proven yet.

Autonomous rooms passed their tests with stub agents; the pilot on real agents was stopped and a full live cycle has not been run.

— from the Parley 0.22.0 release notes

How it works

Official CLIs in a local app.

Parley.app

The window

TerminalRoomsFilesChangesBrowser

unix socket · handshake token

parley-host

Runs every agent's terminal and outlives the window

~/.parley/parley.db

PTY + MCP

Your CLIs

claudecodexGLM via claudeKimiMiniMaxQwenDeepSeekOpenRouter+ your own

  • One host for every terminal.

    parley-host runs the agents' terminals and outlives the window: close the window and they keep working.

  • Agents talk through Parley.

    Every agent gets Parley's MCP server: it reads the shared workspace map, sends and reads messages, and proposes decisions.

  • Mail waits for the turn.

    The host types a short pointer into an agent's terminal only after it finishes its turn, and only urgent mail wakes an idle agent at once.

  • One database.

    Works, letters and rooms live in one SQLite database on your Mac.

Releases

Shipping in the open.

Release notes straight from GitHub: what was added, what changed and what is not proven yet.

The release list didn't load. The notes are on GitHub.

Open releases on GitHub

All releases on GitHub → Changelog

Install

Up and running in three steps.

  1. Download

    Pick the build for your Mac, about 200 MB. Open the .dmg and drag Parley to Applications.

    Apple Silicon Intel

    Not sure? Apple menu → About This Mac shows "Chip" on Apple Silicon and "Processor" on Intel.

  2. Allow the first launch

    Parley is not signed with an Apple Developer ID yet, so macOS blocks the first launch. Run this once in Terminal:

    xattr -dr com.apple.quarantine /Applications/Parley.app

    Or open System Settings → Privacy & Security and click Open Anyway.

  3. Start

    • ⌘NA new workspace: choose a project folder.
    • ⌘TA new session, or a room of two or more agents.
    • Write the task in the room and wait for the lead's decision.

What you need

  • macOS 13 (Ventura) or later, on Apple Silicon or Intel.
  • At least one agent CLI, installed and signed in: Claude Code or Codex. GLM runs through Claude Code with a GLM Coding Plan and a Z.ai API key.
  • git in your PATH.
  • Node.js is not needed: the app carries its own.

Parley checks GitHub once a day and shows a toast when a new release is out. It does not update itself.

Put your agents in one room.

Free and open source under the MIT License.

Download for Mac Star on GitHub