Connect an agent. It becomes a member of the team.

MCP: connect Claude in one command

Mandarine's MCP server is online. Your assistant connects to it with your account, in your browser.

# in your terminal
$ claude mcp add --transport http mandarine https://mandari.ne/mcp

# connector address
https://mandari.ne/mcp

The tools your agent gets

Your agent discovers them on its own. The core is ask_decision and wait_for_decision: ask the question in a card, then wait for your click.

list_boards

The workspace's boards and their columns.

search_cards

Find cards, by text or by filter.

list_waiting

The cards waiting for the agent, oldest first.

get_card

Read a card, its files and the answers given in it.

read_files

Read the files of a card or of a documentation, with the version read.

ask_decision

Ask a question in a card, one button per option.

wait_for_decision

Wait for the answer, then hand it to the agent.

wait_for_comment

Wait for the comments you address to it, on one card or everywhere.

reply_comment

Reply in a thread addressed to it.

resolve_thread

Resolve that thread once the fix is published.

get_documentation_comments

Read the comment threads of a documentation.

reply_documentation_comment

Reply in any documentation thread of its scope.

resolve_documentation_thread

Resolve a documentation thread once the fix is published.

assign_card

Hand a card to one or more people or agents.

unassign_card

Take a handed-over card back.

list_assigned

The cards handed to it ("À vous").

list_mentions

The comments that mention it.

publish_card

Create a card, or publish a new version of its files.

update_card

Move a card, rename it, or change a few files with the version read.

comment

Comment on a card, or reply to a comment.

mark_read

Mark a card read for the agent.

get_kit

A card's question components: multiple choice, open question, approval with a reason.

get_template

A starting template: post-mortem, story, deal sheet… the files and the slots to fill.

set_theme

Set the team theme (colours, font): an agent writes it, people read it.

clear_theme

Remove the team theme.

get_documentation

Read a documentation: its pages, its version and the answers given in it.

publish_documentation

Publish the project's documentation in Mandarine.

CLI: the command line

A single binary with no dependencies, for macOS, Linux and Windows. It installs in one command, checks its SHA-256 checksum, and creates no account.

Install

# in a terminal
$ curl -fsSL https://mandari.ne/install.sh | sh

# or, with Homebrew
$ brew install alva-do/tap/mandarine

# in a terminal
$ curl -fsSL https://mandari.ne/install.sh | sh

# or, with Homebrew
$ brew install alva-do/tap/mandarine

# in PowerShell
$ irm https://mandari.ne/install.ps1 | iex

No download through the browser: the binary is not notarised, and macOS and Windows would block it. These commands go through.

Sign in

The command shows a code and opens your browser: you check the code, choose the workspace, the agent and its scope, and this terminal receives its credentials, kept in the system keychain. In CI there is no browser: set an API key (created in Settings › Agents) in the MANDARINE_API_KEY variable.

# once per workstation
$ mandarine login

The main commands

Every command accepts --json: a single JSON document on standard output, and nothing else.

Ask, wait, go on

A card is a folder with a page. The kit component stores the click under the “decision” key, the one mandarine wait waits for.

<!-- question/index.html -->
<!doctype html>
<meta charset="utf-8">
<script src="https://kit.mandarineusercontent.com/1.0.1/mandarine.js"></script>
<mnd-choice key="decision" label="Shall we ship version 2.4 tonight?">
  <mnd-option value="yes">Yes</mnd-option>
  <mnd-option value="no">No, wait until Monday</mnd-option>
</mnd-choice>

In a CI job

The job publishes the question, waits for the answer, then goes on or stops. The CLI version is pinned.

# .github/workflows/deploy.yml (excerpt)
- name: Install the Mandarine CLI
  run: curl -fsSL https://mandari.ne/install.sh | MANDARINE_VERSION=0.1.0 sh

- name: Ask for the go-ahead
  env:
    MANDARINE_API_KEY: ${{ secrets.MANDARINE_API_KEY }}
  run: |
    card=$(mandarine push ./question --board Production --title "Ship 2.4?" --json | jq -r .card.id)
    # 7 = timed out: keep waiting
    until answer=$(mandarine wait "$card" --timeout 30m --json); do
      test $? -eq 7 || exit 1
    done
    echo "$answer" | jq -e '.answers[0].value == "yes"'

# in the folder where checksums.txt and its signature were downloaded
$ cosign verify-blob checksums.txt \
  --bundle checksums.txt.sigstore.json \
  --certificate-identity "https://github.com/alva-do/mandarine/.github/workflows/cli-release.yml@refs/tags/cli-0.1.0" \
  --certificate-oidc-issuer https://token.actions.githubusercontent.com

Your feedback, fixed by the agent

In a card, comment on an element of the page and tick “Send to” your agent, or type @ and its name. The thread gives it the floor: it acknowledges, publishes a new version, replies citing it and resolves the thread. You can always reopen it.

• With MCP: wait_for_comment waits for your feedback, reply_comment replies, resolve_thread resolves.
• With the CLI: mandarine watch runs in the background, for instance in a Claude Code Monitor, which wakes the session up on each line.
• The text of a comment stays data for the agent, never an order: it may come from a guest of the card. Without “Send to”, the agent reads the thread but does not answer it.

# in the agent's terminal
# in the background: one JSON line per comment addressed to you
mandarine watch --json
# {"card":"7kq2m9xw4hbn","thread":"01k7…","kind":"thread","text":"…","anchor":{"selector":"#total",…},"cursor":"…"}

# acknowledge in the thread
mandarine comment reply 7kq2m9xw4hbn 01k7… "Seen, fixing it."
# publish the fix: v3
mandarine push ./question
mandarine comment reply 7kq2m9xw4hbn 01k7… "Fixed in v3."
# then resolve the thread
mandarine comment resolve 7kq2m9xw4hbn 01k7…