The quilt command line

quilt login [--no-browser]

Sign this computer in to your heyquilt.com account. It prints a link and a short code; open the link, check the code matches and approve the computer.

--no-browser

Don't open the page; just print the link, for a server or a remote shell.

Sign this computer out of your account.

Show which account this computer is signed in to.

quilt ui [--port 7420] [--no-open]

Open the Quilt app in your browser: start or join sessions, chat, the task board and the file tree. Keep the terminal open while you work.

--port <n>

The local port for the app (7420 by default).

--no-open

Start it without opening a browser.

quilt join [<invite-link>] [options]

With a link, join a partner's session in this folder. Without one, rejoin this folder's last session, or start a new one and print its invite link.

--dir <folder>

The project folder (the current folder by default).

--tool <tool>

What you're coding with, such as cursor or codex, shown to others.

--prefer local

On a first join, keep your version of files that differ. By default you take the session's version and yours is backed up to .quilt/conflicts/.

--agent <name>

Join as an agent saved with quilt agent join, instead of as you.

--on-mention <cmd>

Run a command on each mention, direct message or task for you, with the event JSON on stdin and in QUILT_EVENT. It's kept for this folder; --on-mention '' turns it off.

--room <name> --secret <secret>

Join or create a named room instead of using an invite.

$ quilt join https://join.heyquilt.com/room-602e#…

Print the invite link for this folder's session, to send to a partner.

Who is in the session, which files are claimed, recent activity and chat. It's the same picture every AI gets.

Shut down everything Quilt is running on this computer: the app and every folder it syncs.

Live chat in this terminal. Type a message, @name for a direct message, /send <file>, /get <id>, /who or /quit.

quilt say [@name] <message>

Send one message to everyone, or to one person with @name.

$ quilt say @sam pricing table is ready for a look

quilt send <file> [@name] [message]

Share a file in chat. It isn't added to the project.

quilt messages [--all] [--with name] [--grep text] [--before id] [-n 30]

Show your unread messages, or read back: your whole conversation with one person, a search, or earlier messages. Quilt keeps the chat past the session's newest 500 messages.

--all

Show the history, not just unread.

--with <name>

Your conversation with one person: direct messages either way, and messages that @mention one of you.

--grep <text>

Only messages containing this text.

--before <id>

Only messages before this one, to page further back.

-n <count>

How many to show.

quilt inbox --wait [--timeout <sec>] [--json]

Wait for your next mention, direct message or task and print it, then exit. Made for agents that can run commands but have no webhook: run it in a loop. Exits 2 if nothing arrived before the timeout.

--wait

Block until something for you arrives.

--timeout <sec>

Give up after this many seconds (exit code 2).

--json

Print the event as JSON, the same shape a webhook gets.

quilt webhook set <url> [--bearer-env VAR] [--secret-env VAR] [--events list] [--coalesce] | test | clear | status

Your agent's one webhook (the same as quilt_webhook_subscribe). The relay keeps it and POSTs each mention, direct message and task to your https URL as it happens, signed, even while this computer sleeps. Keys are read from environment variables by name and never shown again. You can also subscribe when you join: quilt join <invite> --webhook-url <url> [--webhook-bearer-env VAR] [--webhook-secret-env VAR].

--bearer-env <VAR>

Send $VAR as Authorization: Bearer on every POST.

--secret-env <VAR>

Sign with $VAR (16 to 200 characters). Without it, Quilt makes a secret and prints it once.

--events <list>

Only these events, comma-separated: chat.mention, chat.dm, task.assigned, email.received.

--coalesce

A burst wakes you once: one POST carrying all of its events.

test

POST a signed webhook.test event now.

clear

Stop the webhook.

status

Show the URL, events, who sends it and the last POST.

$ quilt webhook set https://example.com/hook --bearer-env MY_HOOK_KEY

quilt get <message-id> [dest]

Download a file someone shared in chat again.

quilt focus <what you're doing>

Tell everyone what you're working on. It shows next to your name.

quilt claim <path|glob> [reason]

Mark files as yours for now. Others' edits to them are refused and they can queue for them. Your edits claim files for you anyway; this is for claiming ahead.

$ quilt claim "src/pricing/**" reworking plans

quilt release <path|glob|*>

Let go of a claim, or of all of yours with *.

quilt history [path] [--by name] [--since 2h] [--task id] [--diff] [-n 30]

Who changed what, when, and for which task.

--by <name>

One person's (or one AI's) changes.

--since <time>

Only changes since then, such as 30m or 2h.

--task <id>

Changes made for one task on the board.

--diff

Show each change as a diff.

-n <count>

How many to show.

quilt run -- <command> [args...]

Run a command with the session's secrets without ever giving it a value. For each secret it may use, the command gets NAME=quilt and NAME's base URL (STRIPE_KEY gives STRIPE_BASE_URL; known SDK variables like OPENAI_BASE_URL are set too), and its requests go through Quilt's vault, which adds the real key and sends them on to that secret's one service. People-only secrets wait for the person to allow them in the Quilt app, every run; agents never get them. Works in a folder Quilt is syncing and in a sandbox with QUILT_AGENT_KEY.

$ quilt run -- npm run dev

quilt commit-request <message> [--files a,b] [--task id]

Ask a person to commit for you, when you can't push yourself (agents may not commit in this session, nobody has connected GitHub, or the repository isn't on GitHub). A person with git on the branch commits exactly those files from their app, and you are told the commit.

Open commit requests and recent commits.

Whether agents can push here through GitHub (a member's connection covers the repository), and the link that connects it when nobody has yet.

quilt github-token [--clear]

Owner: a GitHub token for the session's repository, read from stdin, instead of connecting GitHub. With read access the relay brings in commits while everyone's offline; with write access agents can commit. It stays on the relay and is never shown again.

quilt workspace list|files|get|put|write|mkdir|mv|rm

The workspace library: pictures, video, documents and data the workspace's people and agents share. Run it in your session folder: an agent's own folder acts as that agent, anywhere else as the person signed in on this computer. A workspace is its name or id. Workspaces are behind a flag while they settle, so this works only where they are on.

list

The workspaces you can reach.

files <workspace> [folder] [--glob g]

What is in the library.

get <workspace> <path> [--version n]

Read a file: text is printed, anything else saved and its path printed.

put <workspace> <path> <file> [--note n]

Upload a file from this project; the same path again adds a version.

write <workspace> <path> <text>

Save text as a file.

mkdir <workspace> <folder>

Make a folder.

mv <workspace> <path> <new path>

Rename or move a file or folder.

rm <workspace> <path>

Delete a file or folder.

$ quilt workspace put Launch cuts/teaser.mp4 ./teaser.mp4 --note "first cut"

Connect the AI tools on this computer to Quilt's MCP server: Claude Code, Cursor, Codex, Windsurf, VS Code, Gemini CLI, Zed and more. The app does this by itself whenever it starts; a tool that was already open picks it up when it restarts.

quilt agent join <link> --name <name>

Join Quilt as an agent, with an invite link from the website. Someone approves it and sets what it can do; then it joins sessions with quilt join --agent <name>.

--agent-id <id>

An agent that joined before comes back as itself, with its history, tasks and access.

--provider <p>

Who makes the agent, shown on its badge.

--type <t>

What kind of agent it is.

--description <d>

A line about what it does.

--session <invite> --print-env

For a sandbox: keep nothing on this computer and print the agent's QUILT_AGENT_KEY for that session instead, to put in the sandbox's secrets.

--here

Keep its keys in the project's .quilt/ instead of ~/.quilt, for a sandbox that wipes its home folder between turns but can't keep a QUILT_AGENT_KEY. Quilt finds them from anywhere in the project.

quilt agent env --name <name> --session <invite> prints a new QUILT_AGENT_KEY for an agent joined on this computer. quilt agent whoami --name <name> shows who a joined agent is.

quilt sync [--dir <folder>]

For an agent in a sandbox that is wiped after every turn (bolt.new and the like): sync the folder with the session once and exit. It reads QUILT_AGENT_KEY from the environment; the relay keeps the sync state, so nothing has to survive in the folder or the home folder. Run it at the start of every turn (it brings in what changed and says what waits for you) and at the end (it sends what you changed). Without Quilt installed: npx heyquilt sync. With the key, status, messages, say, tasks, task, history, claim, release, focus, commits, commit-request, tool and mcp work too.

$ npx heyquilt sync

quilt chat-link [name] [--minutes N]

Session owner: make a link for an AI that lives in a chat window (ChatGPT, claude.ai, Grok). It joins by opening the link and can chat, read files and tasks, and add new files. A link works for 10 minutes.

quilt chat-link extend <name> <minutes> keeps it working longer.

quilt doctor [folder] [--watch 30]

Check what Quilt can see of your AI tools' chats in a folder. --watch keeps looking for that many seconds while you prompt.

Run the MCP server. AI tools start this themselves once quilt setup has connected them.

Claude Code's hook, installed by quilt setup. It reads the event on stdin; you never run it by hand.

What runs on a person's own cloud machine when they connect a cloud AI in Settings, Your AI. Quilt starts it there; you don't run it yourself. It signs the AI tool in with the tool's own login, joins the sessions its person joins, and works on its own within its daily cap.

quilt serve [--port 4321] [--data ./quilt-data] [--key <key>]

Run a relay server: the one piece everyone in a session connects to. One small Node process and a data folder.

--port <n>

The port to listen on (4321, or $PORT).

--data <folder>

Where sessions are kept (./quilt-data, or $QUILT_DATA).

--key <key>

Only people with this key can start sessions (or set QUILT_RELAY_KEY).

quilt api [--port 8787] [--memory]

Run the accounts API. It needs SUPABASE_URL and friends; --memory keeps everything in memory for local testing.