# Account, security and plans (/docs/account)
Your settings are on the web. Open the menu at the bottom of the sidebar, where your email is, and choose:
* **Settings · Personal** for what's yours: your name and email, sign-in protection, signed-in devices, API tokens and how Remi talks to you.
* **Settings · Account** for what you share with your team: members, plan, billing and usage.
## Sign in [#sign-in]
There's no password. Enter your email at [remiapp.ai](https://remiapp.ai) and select **Continue**, then type the 6-digit code Remi emails you. The code works for 10 minutes. Or select **Sign in with Google**.
A new email creates a new account, so there's no separate sign-up. [Install Remi and sign in](/docs/install#sign-in) covers signing in to each app.
### Approve a sign-in from another Remi app [#approve-a-sign-in-from-another-remi-app]
Remi Desktop and the Remi CLI can send you to remiapp.ai to approve their sign-in. The page asks **Approve this sign-in?** and shows the device, its IP address and a code.
1. Check the code matches the one the app shows you.
2. Select **Approve**. If you didn't start the sign-in yourself, select **Deny**.
## Turn on two-factor authentication [#turn-on-two-factor-authentication]
Add a passkey or an authenticator app, and Remi asks for it every time you sign in, after the email code or Google. You can add both.
Go to **Settings · Personal** › **Security**.
A passkey lets you confirm it's you with your fingerprint, face or device PIN. You can add one for each device you use.
1. Select **Add a passkey**, then **Create passkey**.
2. Follow your browser's prompt.
3. Give the passkey a name you'll recognise, such as "MacBook Touch ID", and select **Save**.
If your browser says it doesn't support passkeys, add an authenticator app instead.
Use any authenticator app, such as Google Authenticator or 1Password. You can have one authenticator app on your account.
1. Select **Add an authenticator app**.
2. Scan the QR code with your app, or copy the **Setup key** into it. Select **Continue**.
3. Type the 6-digit code your app shows.
4. Remi shows your recovery codes. Select **Copy all** or **Download**, keep them somewhere safe, then select **I've saved my recovery codes**.
### Check it worked [#check-it-worked]
Your passkey or authenticator app is listed under **Security**. The next time you sign in, Remi shows **Verify it's you** after the email code or Google.
### Sign in when you've lost your phone or passkey [#sign-in-when-youve-lost-your-phone-or-passkey]
On **Verify it's you**, select **Use your authenticator app instead**, **Use a passkey instead** or **Use a recovery code**. Each recovery code works once.
### Recovery codes [#recovery-codes]
Recovery codes get you in if you lose your passkey and your phone. Remi shows them once, so save them when they appear.
* To get a set after adding a passkey, go to **Security** and select **Generate** next to **Recovery codes**.
* To replace a set, select **Regenerate recovery codes**. If you see **Contact support to replace these** instead, select it to ask the Remi team.
### Remove a passkey or authenticator app [#remove-a-passkey-or-authenticator-app]
Open the **More actions** menu (⋯) next to it and choose **Remove**. With more than one, the same menu has **Set as default**, which chooses the one Remi asks for first when you sign in.
### When Remi asks you to verify [#when-remi-asks-you-to-verify]
Once you've added a passkey or authenticator app, Remi asks you to confirm it's you before changing billing, changing how you sign in, changing your email or creating an API token. Creating an API token, replacing recovery codes and connecting a bank account all need two-factor authentication turned on first.
## Your signed-in devices [#your-signed-in-devices]
**Settings · Personal** › **Signed-in devices** lists every place you're signed in to Remi. The browser you're reading it in comes first, marked **This device**.
### What each device is called [#what-each-device-is-called]
| Device | How it's listed |
| --------------------- | ------------------------------------------------------------------------------ |
| A web browser | The browser and the system it runs on, such as "Chrome on macOS" |
| Remi for iPhone | Remi for iPhone |
| Remi for Android | Remi for Android |
| Remi Desktop | "Remi Desktop on" and the computer's system, such as "Remi Desktop on Windows" |
| The Remi CLI | "Remi CLI on" and the computer's name, such as "Remi CLI on work-laptop" |
| The browser extension | Remi for your browser |
Each one also shows the IP address it signed in from. If Remi can't tell what a device is, it's listed as **Unknown device**. API tokens aren't listed here: they're under **API tokens**, further down the same page.
### What "last active" means [#what-last-active-means]
**Last active** is the last time that device renewed its sign-in with Remi. A device that's in use renews it at least every 30 minutes, so a device you're using shows a recent time. One that has been closed for a while shows when you last used it.
Each sign-in lasts 30 days. After that, the device asks you to sign in again, even if you've used it every day.
### Sign a device out [#sign-a-device-out]
1. Select **Sign out** next to the device.
2. Read **Sign out of** and the device's name, then select **Sign out** to confirm.
The device stops working with Remi straight away, and anything running there, such as the Remi CLI, stops too. To use Remi on it again, sign in there again.
The device you're reading on has no **Sign out** button. To sign out of it, choose **Log out** from the menu at the bottom of the sidebar instead.
### A device you don't recognise [#a-device-you-dont-recognise]
Sign it out first. Then make sure nobody can sign in as you again:
1. Remi signs you in with a code sent to your email, or with Google. Someone who signed in as you could read your email or use your Google account, so change those passwords and check their security settings.
2. [Turn on two-factor authentication](#turn-on-two-factor-authentication), so a sign-in also needs your passkey or authenticator app.
3. Under **API tokens**, revoke any token you didn't create.
4. Come back to **Signed-in devices** to check the device hasn't reappeared.
## Create an API token [#create-an-api-token]
An API token lets the Remi CLI act as you where nobody can approve a sign-in, such as a CI job or a script. You need two-factor authentication turned on first.
1. Go to **Settings · Personal** › **API tokens** and select **Create token**.
2. Give it a **Name** after where you'll use it, such as "GitHub Actions".
3. Under **Expires**, choose **In 7 days**, **In 30 days**, **In 90 days**, **In 1 year** or **Never**.
4. Select **Create token**, and confirm it's you.
5. Select **Copy token**. Remi shows it only this once. Store it as a secret, then select **I've saved it**.
Give the token to the Remi CLI as `REMI_TOKEN`. [Use Remi in scripts and CI](/docs/cli-config#use-remi-in-scripts-and-ci) has the steps.
To stop a token working, select **Revoke** next to it, then **Revoke token**. Anything using it stops straight away.
## Change your email [#change-your-email]
1. Go to **Settings · Personal** › **General** and select **Change email**.
2. Enter your **New email** and select **Send verification code**.
3. Type the code Remi sends to the new address.
## Your plan [#your-plan]
There's no charge per person. Each plan sets how many people can be on the account and how much Remi you can use each month.
| Plan | People |
| -------- | -------- |
| Free | Up to 2 |
| Starter | Up to 5 |
| Team | Up to 15 |
| Business | Up to 30 |
For prices and what else each plan includes, see [remiapp.ai/pricing](https://remiapp.ai/pricing). The Free plan needs no credit card and has no time limit.
### See your usage [#see-your-usage]
Choose **Usage** from the menu at the bottom of the sidebar. It shows how much of this month's allowance the account has used, when it resets and who's using it. The allowance resets each billing cycle.
When the account has used its allowance, Remi says **You've used this month's allowance**. An owner or admin can then top up or upgrade.
### Change your plan or top up [#change-your-plan-or-top-up]
Only an owner or admin can change the plan or buy top-ups.
1. Choose **Plan & billing** from the menu at the bottom of the sidebar.
2. Under **Available plans**, choose **Monthly** or **Annual**, then select **Upgrade**, **Downgrade** or **Subscribe** on the plan you want.
3. Confirm, and enter your card details if Remi asks for them.
An upgrade takes effect straight away. A downgrade takes effect at the end of your billing period, and you keep your current plan until then.
On a paid plan, **Top up** adds extra usage that carries over. Remi uses it only once the monthly allowance runs out, and it's valid for 12 months. On the Free plan, upgrade first.
The same page has your **Payment method** and **Invoice history**. For a team bigger than Business, select **Contact us** under **Enterprise**.
## Invite your team [#invite-your-team]
Owners and admins can invite people.
1. Go to **Settings · Account** and find **Invite a teammate**.
2. Enter their email and select **Send invite**.
They join with the Member role. Owners and admins can change a member's role, or remove them, from the list of **Team members**. [Team roles](/docs/team-roles) says what each role can do.
## Delete your account [#delete-your-account]
Only the account's owner can ask for this.
1. Go to **Settings · Account**.
2. Under **Danger zone**, select **Request account deletion**.
3. Check the details and select **Send request**.
This sends a request to the Remi team. Nothing is deleted until they reply, by email and in **Help & support**. [Privacy and your data](/docs/privacy) says how long Remi keeps data after an account closes.
## Sign out [#sign-out]
Choose **Log out** from the menu at the bottom of the sidebar.
# Approvals, Autopilot and pick up anywhere (/docs/approvals-autopilot)
Remi asks before it does things you might not want, such as creating something, acting in one of your apps or deleting. You answer each request, or allow an action for the rest of a chat.
## Answer a request [#answer-a-request]
When Remi needs your OK, it stops and shows what it wants to do, for example **Remi wants to send an email**, with the recipient, subject and message. The choices are in the message box, and which ones you see depends on the request:
| Choice | What it allows |
| ---------------------- | ------------------------------------------------------------------------------------------------------- |
| **Allow once** | This action, this time. Remi asks again next time. |
| **Allow in this chat** | The same action for the rest of this chat, without asking again. |
| **Always** | The same action in that app, in every chat, until you revoke it. Offered only for actions in your apps. |
| **Deny** | Nothing: Remi doesn't do it. |
* To have Remi do something else instead, type it in the message box, which reads **Or tell Remi what to do instead…**, and send it.
* When Remi wants to delete something, it offers only **Allow once** and **Deny**, so it asks every time.
* When more than one request is waiting, Remi shows them one at a time, with how many more approvals are needed.
## What Remi asks about [#what-remi-asks-about]
Remi asks before it:
* creates a document, data table, task, project, workspace or workflow, copies a workflow, invites someone, makes an image, video or audio, or changes your profile. It asks each time, unless you've chosen **Allow in this chat** for that action;
* does something in a connected app that changes something, such as sending an email or adding a calendar event. Reading, such as searching your mail, goes ahead without asking;
* uses any tool of an app you added by its MCP server address, unless the app marks that tool as read-only.
Workflows run with nobody to ask, so they follow their own rules: see [What a workflow does without asking](/docs/workflows-tasks#what-a-workflow-does-without-asking).
## Take back a permission [#take-back-a-permission]
* **For one chat:** in the sidebar, point at the chat, select **…**, then **Permissions**. It lists what you allowed for the rest of that chat. Select **Revoke** on any of them, and Remi asks again next time.
* **For an app:** select your email address at the bottom of the sidebar, then **Integrations**, and open the app. On its **Tools** tab, **Standing decisions** lists the tools you allowed or blocked for good. Select **Revoke**, and Remi asks again next time.
## Let Remi work on its own with Autopilot [#let-remi-work-on-its-own-with-autopilot]
Autopilot is a mode for sessions that work in a folder on your computer, in the [Remi CLI](/docs/cli) and [Remi Desktop](/docs/desktop). [Which app is for what](/docs#which-app-is-for-what) shows whether each one is out yet.
In Autopilot, Remi edits files and runs commands without asking. Commands run in a sandbox that can only write in the project folder, temporary folders and tool caches. In the Remi CLI, the sandbox also can't reach the network.
To turn it on:
* **Remi CLI:** press **Shift+Tab** until the mode under the input box reads Autopilot, or type `/autopilot`. To start in it, run `remi --mode autopilot`.
* **Remi Desktop:** in Settings, under **Models and permissions**, turn on **Allow Autopilot**. Then choose **Autopilot** from a folder session's **Mode** menu. If you turn **Allow Autopilot** off again, sessions on Autopilot go back to **Edit freely**.
Where there's no sandbox, Autopilot still asks before every command: on Windows, and on Linux without `bwrap` installed. Remi Desktop says so under **Allow Autopilot** when the computer can't sandbox commands.
### What Autopilot always asks about in the Remi CLI [#what-autopilot-always-asks-about-in-the-remi-cli]
Even in Autopilot, the Remi CLI asks before a command that:
1. **Needs the network**, such as `git push`, `git pull` or `git clone`; installing or publishing packages with npm, pnpm, yarn, bun, pip, uv, cargo, go, gem or brew, or running `npx`; `curl`, `wget`, `ssh`, `scp` or `rsync`; and tools such as `gh`, `aws`, `gcloud`, `kubectl`, `terraform` and `docker`.
2. **Names a file that may hold secrets**, such as `.env` files, keys and credentials. Templates such as `.env.example` don't count.
3. **Throws away git history that undo can't bring back**, such as `git reset --hard`, `git clean`, `git stash drop`, `git branch -D` and rebases.
4. **Deletes files**, with `rm`, `rmdir`, `unlink`, `shred`, `trash` or `find … -delete`.
5. **Runs as another user**, with `sudo`, `doas`, `su` or `pkexec`.
6. **Reaches outside the project folder**, with an absolute path, `~` or `..`. Temporary folders are fine.
7. **Is too complex to check**, such as `$(…)`, backticks, `eval`, or code passed straight to an interpreter, such as `python -c` or `node -e`.
Edits go ahead in Autopilot, except to files that change how Remi and your tools behave. Those always ask: `.remi/`, `.claude/`, `.git/hooks`, `.git/config`, `.mcp.json`, `.husky/`, `.vscode/` and `.envrc`.
### What Autopilot always asks about in Remi Desktop [#what-autopilot-always-asks-about-in-remi-desktop]
Even in Autopilot, Remi Desktop asks before a command that:
1. **Deletes files**, such as `rm`, `git rm` or `git clean`.
2. **Installs software**, with a package manager such as npm, pnpm, yarn, pip, cargo, brew or apt, or runs a package straight from the internet, such as `npx` or `curl … | sh`.
3. **Signs in**, such as `npm login`, `gh auth`, `docker login` or `gcloud auth`.
4. **Sends work out of your computer**, such as `git push`, publishing a package, deploying, or `ssh`, `scp` and `rsync`.
5. **Runs as another user**, with `sudo`, `doas` or `su`.
6. **Is too complex to check**, such as `$(…)`, backticks, `eval`, `xargs` or `sh -c`.
Other commands run in the sandbox without asking, including ones that use the network. Edits go ahead, except to `.mcp.json`, which always asks. So does every tool of a connected app.
## Pick up a chat on another device [#pick-up-a-chat-on-another-device]
Chats on the web, your phone and Remi Desktop share one list. Open the chat on whichever device is closest and carry on. On the web, a request Remi is still waiting on shows when you open the chat, and you can answer it there.
## Pick up a folder session from another device [#pick-up-a-folder-session-from-another-device]
A session working in a folder on your computer, in the Remi CLI or Remi Desktop, stays in that app and isn't in your chat list. While it's open, you can still carry it on from the web, your phone or another computer. What you send from there runs on the computer that has the folder, with that folder's rules.
1. In the Remi CLI, type `/handoff` to open the chat on the web or your phone.
2. Send a message there. Remi works in the folder on your computer, and the answer shows in both places.
When Remi needs your permission, the request shows on your other devices too, and you get a notification that Remi is waiting for your OK. Select the notification to open the chat. On the web, answer with **Allow once**, **Allow in this chat** or **Deny**. The first answer wins, wherever it comes from.
* **The computer has the final say.** Every answer is checked again against the folder's rules before anything runs, and a deny rule always wins.
* **Allow in this chat** from another device allows that exact command, or that one file, again for the rest of the session. For a protected file or an MCP tool, it allows the call just once.
* **A request nobody answers in time expires**, and counts as a no.
* **If a request waits a minute** on your computer without an answer, your phone is asked too.
* **Stop works from any device.**
* **If the computer is off, asleep or offline**, Remi can't reach the folder, so it answers without it.
### Bring the session back to your computer [#bring-the-session-back-to-your-computer]
The last place you typed in, or chose to continue in, is the one that serves your other devices. To bring a session back, type in it on your computer. Or:
* in the Remi CLI, type `/host`;
* in Remi Desktop, select **Continue here**, which shows when the session has moved somewhere else.
To stop a CLI session taking messages from your other devices, type `/host off`, or start it with `remi --no-host`. Pick up anywhere doesn't work with `remi -p`, or when the CLI is signed in with an access token (`REMI_TOKEN`).
## Next [#next]
# Browser extension (/docs/browser-extension)
> **Coming soon.** Browser extension isn’t out yet.
## What it does [#what-it-does]
* **Ask about the page you're on.** Open the side panel and ask. Remi reads the page, PDFs included, alongside your projects and documents. You can add other open tabs to the same question.
* **Save what you find.** A page to your library, a selection as a clip, a task or something to remember, a link to your reading list, or a table as a Remi table.
* **Your chats, beside the page.** The chats from the web, your phone and Remi Desktop, with search down to a single message.
* **Dictate into any text box.** Speak, and Remi writes the tidied words where you were typing, Google Docs included.
* **Work in your tabs.** Remi can read, click, type and fill in forms, and asks you first before anything important.
* **Teach it a task once.** Do a task while Remi watches, and it keeps the steps as a workflow any chat can run.
## Before you start [#before-you-start]
* **A Chromium browser on a computer:** Chrome, Edge, Brave, Opera or another. Versions for Firefox and Safari on the Mac are on their way.
* **A Remi account.** [Sign up on the web](https://remiapp.ai) if you don't have one.
* **A microphone**, if you want to dictate.
## Install [#install]
Remi isn't in the extension stores yet, so you add it by hand.
1. Go to [remiapp.ai/apps/browser](https://remiapp.ai/apps/browser) and select **Download for Chrome, Edge and Brave**.
2. Unzip the download into a folder you'll keep. Remi runs from that folder.
3. Open `chrome://extensions` (`edge://extensions` in Edge, `brave://extensions` in Brave), and turn on **Developer mode**.
4. Select **Load unpacked** and pick the folder.
5. Pin Remi to the toolbar: open the extensions menu (the puzzle piece) and select the pin next to Remi.
A welcome tab opens with the next steps.
## Sign in [#sign-in]
Select the Remi icon in the toolbar, or press **Alt+R** (**Option+R** on a Mac). The side panel opens.
Select **Continue in your browser**. Remi opens remiapp.ai, where you're probably signed in already.
Check that the page shows the same code as the panel, then approve it.
You can also select **Other ways to sign in** and type a code Remi emails you.
Remi follows remiapp.ai in the same browser: signing out there, or into another account there, signs Remi out too.
## Check it worked [#check-it-worked]
The chats you started on the web appear in the panel's **Chat history**.
## Choose where Remi can go [#choose-where-remi-can-go]
Remi reads a site only once you've allowed it. The first time you ask about one, Remi asks, and your browser asks once for that site. To skip that for every site, turn on **Access to all sites** in Settings.
For the site you're on, Settings › **Remi on** the site gives you three choices:
| Setting | What Remi can do there |
| ------------- | ------------------------------------- |
| **Allow** | Read the page and work in it. |
| **Read only** | Read the page, but not click or type. |
| **Block** | Nothing: Remi stays out entirely. |
Remi stays out of banking, payment and password sites unless you choose **Allow** on one. It can't read the browser's own pages, such as settings or the extension store.
## Ask about the page [#ask-about-the-page]
Open the panel on any page and type your question. When you ask about the page, Remi takes it along, and the message shows that it did. **Include this page** adds it yourself, and **Tabs** adds up to eight other open tabs from the same window.
You can also select text, right-click and choose **Ask Remi about** it, or right-click an image or a link and ask about that.
## Save to Remi [#save-to-remi]
From **Save to Remi** in the panel:
* **Save page to library**, **Add to reading list** or **Make it a task**, for the page you're on. **Save to** picks a project.
* **Save this tab group as a project**, when the page is in a tab group.
* **Save as Remi table**, for each table on the page.
* **Watch this page for changes**: Remi checks every hour and tells you when it changes.
Or right-click on the page:
* **Save page to Remi library**, or **Make a task from this page**.
* With text selected: **Save selection to library**, **Turn selection into a task** or **Remember this**.
* On an image or a link: **Save image to Remi**, **Save linked file to Remi** or **Add to reading list**.
**Alt+Shift+S** saves the page you're on. What you saved is highlighted on the page when you come back, with your notes beside it.
If Remi can't reach your workspace, a save waits and goes out by itself later. **Save to Remi** shows what's waiting, with **Retry now**.
## Your chats [#your-chats]
The panel's **Chat history** has your workspace's chats from the web, your phone and Remi Desktop. Search finds chat titles and the words in messages. If Remi can't reach your workspace, you can still read your recent chats.
From the address bar: type `remi`, a space, and a few words. Chats that match show as suggestions, and Enter asks Remi what you typed.
## Dictate [#dictate]
### In the panel [#in-the-panel]
Select the microphone in the message box, or press **Alt+Shift+D**. Speak, then select it or press **Alt+Shift+D** again. Remi puts the tidied words in the message box.
The first time, your browser asks for the microphone in a small Remi window: allow it there, and Remi starts listening.
### Into a page [#into-a-page]
1. Click in a text box on the page, such as an email or a comment.
2. Press **Alt+Shift+D** and speak. A small bar at the bottom of the page shows Remi is listening.
3. Press **Alt+Shift+D** again, or select **Done**. Remi writes the tidied words where you were typing.
Press **Esc** while Remi is listening to cancel. On a site Remi isn't allowed on yet, right-click the text box and choose **Remi** › **Dictate here**. Remi never listens for password or card fields, and never on a site you blocked.
**Google Docs and Slides** work too, where your cursor is. Remi can't see the text before your cursor there, so it doesn't add a space in front of the words: type the space first if you need one.
To turn dictation into pages off, use **Dictate into text boxes** in Settings.
What you say goes through your Remi account to a speech service that writes it down, and then Remi tidies it.
## Let Remi work in your tabs [#let-remi-work-in-your-tabs]
Remi can open and switch tabs, read pages, click, type, fill in forms, choose options, scroll and take screenshots. You can ask from the panel, or, with **Let my Remi chats use this browser** on in Settings, from a chat on the web, your phone or Remi Desktop while this browser is open.
While Remi works in a tab, a purple frame goes round it. Select **Stop**, on the page or in the panel, to stop it at any time.
### What Remi asks you first [#what-remi-asks-you-first]
With **Ask before important actions** on, which is the default, Remi asks before it:
* buys something,
* sends something,
* deletes something,
* fills in a password or card field.
It asks in a small Remi window the page can't reach. Only your click on **Allow** counts. If nobody answers, nothing is done.
Remi never acts on a site that's **Read only** or **Block**. If a page contains instructions, Remi treats them as words on the page, never as a request from you.
Settings › **What Remi did in this browser** lists what Remi read and did, and says when you allowed it.
**Precise mode**, in Settings, uses real mouse and keyboard input, for editors that ignore simulated clicks. Chrome shows a "debugging" bar while Remi works in that mode.
## Teach Remi a task [#teach-remi-a-task]
1. On the tab where the task starts, open **Teach Remi a task** in the panel and select **Start on this tab**.
2. Do the task as usual. Remi notes each step in words. It never records passwords or card numbers.
3. Select **Done**, name the task, remove any steps you didn't mean, and mark the values Remi should ask for each time.
4. Select **Save as workflow**.
Run it from **Teach Remi a task**, or ask for it by name in any Remi chat while this browser is connected. You can also run it on a schedule.
## Notifications [#notifications]
Remi's notifications, such as a routine that finished or an approval waiting, show in your browser while Remi is connected. Reading one anywhere clears it. If you've turned on browser notifications at remiapp.ai in the same browser, they show them instead, so nothing arrives twice.
**Tell me when an answer is ready** lets you know when a chat in the panel finishes answering while the panel is closed. Both are in Settings.
## Sign out [#sign-out]
In Settings, select **Sign out**. If saves are still waiting to go out, Remi asks first: signing out drops them.
Signing out removes what Remi kept in this browser, such as your recent chats and highlights. Your chats and everything you saved stay in your Remi account.
## Keyboard shortcuts [#keyboard-shortcuts]
| Shortcut | What it does |
| --------------------------------- | -------------------------- |
| **Alt+R** (**Option+R** on a Mac) | Open the side panel |
| **Alt+Shift+S** | Save the page you're on |
| **Alt+Shift+D** | Dictate, and again to stop |
To change them, open `chrome://extensions/shortcuts`.
## Which browsers [#which-browsers]
* **Chrome, Edge and Brave:** install by hand, as above.
* **Opera, Vivaldi and other Chromium browsers:** the same download. Where a browser has no side panel, Remi opens from the toolbar as a popup instead.
* **Firefox and Safari on the Mac:** on their way.
## Update or remove [#update-or-remove]
Remi tells you at the top of its panel when a new version is out. To update a copy you installed by hand:
1. Download the new version.
2. Empty Remi's folder and unzip the new one into it.
3. Select **Restart Remi** in the panel.
Use the same folder each time, which keeps you signed in.
To remove Remi, right-click its icon and choose **Remove**, or remove it on your browser's extensions page. That deletes everything it kept in this browser. Your chats and everything you saved stay in your Remi account.
# Chats, projects and documents (/docs/chats-projects-documents)
This page covers Remi on the web, at [remiapp.ai](https://remiapp.ai).
## Start a chat [#start-a-chat]
1. Select **New chat** at the top of the sidebar.
2. Type in the **Message Remi...** box and press **Enter**.
Remi's answer appears under your message as it's written.
**Check it worked:** the chat is in the sidebar under **Recent chats**.
While Remi is working, you can send another message: Remi picks it up at its next step. To stop Remi, select the square stop button (**Stop**).
The model menu in the message box shows **Remi Auto** until you choose a model, and Remi picks the model for you. To use a particular model, choose it from that menu.
## Add files to a chat [#add-files-to-a-chat]
Drag files into the chat, or paste them. Or select the paperclip in the message box (**Add attachment**), then **Upload from device** or **Choose from documents**.
Remi reads PDFs, Word and Excel files, images, text and code. Each file can be up to 50 MB.
## Find a chat [#find-a-chat]
* **Recent chats** in the sidebar lists your chats under **Today**, **Yesterday**, **Previous 7 days** and **Previous 30 days**, the most recent first.
* **Search everything**, at the top of the sidebar, finds chats, projects, documents, tasks and workflows. To open it from anywhere, press ⌘K on a Mac, or Ctrl+K on Windows and Linux.
## Rename or delete a chat [#rename-or-delete-a-chat]
1. In the sidebar, point at the chat and select **…**.
2. Choose **Rename** or **Delete**.
Deleting a chat deletes all of its messages, and it can't be undone.
The same menu has **Permissions**: what you've allowed Remi to do in that chat without asking. [Take back a permission](/docs/approvals-autopilot#take-back-a-permission) explains it.
## Try another direction [#try-another-direction]
To take a conversation somewhere new without losing it, point at a message and select its branch icon, **Branch from here**. Remi opens a new chat that starts with a copy of the conversation. The original is unchanged.
## Carry on from another device [#carry-on-from-another-device]
Chats on the web, your phone and Remi Desktop share one list, so you can open a chat on any of them and carry on where you left off.
Sessions that work in a folder on your computer, in the Remi CLI or in Remi Desktop, aren't in that list. They stay in the app that runs them, and you can steer them from the web or your phone: see [Pick up a folder session from another device](/docs/approvals-autopilot#pick-up-a-folder-session-from-another-device).
## Start a project [#start-a-project]
A project keeps the documents, facts and chats for one client, case or goal in one place.
1. Select **Projects** in the sidebar, then **New project**.
2. Give it a **Name**. Add a **Description** if you like, and a **Deadline**, or tick **Ongoing (no end date)**.
3. Choose its **Visibility**: **Open**, so all team members can see it, or **Private**, so only invited members can.
4. Select **Create**.
**Check it worked:** the project opens, with the tabs **Overview**, **Documents**, **Facts** and **Data**.
You can also ask in a chat, for example "Create a project called Acme rebrand". Remi asks first, unless you've already allowed it in that chat.
## Add documents and facts to a project [#add-documents-and-facts-to-a-project]
* **Documents** tab: select **Upload** to add files to the project, or **Link existing** to add documents already in your workspace.
* **Facts** tab: select **Add fact**, type it, and select **Save**. Remi uses a project's facts in chats about that project.
To work on a project in a chat, type `#` in the message box and pick the project, or select the folder button in the message box (**Reference a project**). Remi then knows which project you mean.
## Share a project with your team [#share-a-project-with-your-team]
Project admins see a **Settings** tab on the project:
1. Open the project and select **Settings**.
2. Under **Team**, select **Add team**, and choose people from your account.
**Visibility** is on the same tab. A private project is only for the people on its team. An open project is visible to everyone in the workspace.
## Add documents [#add-documents]
1. Select **Documents** in the sidebar.
2. Select **Upload** and choose your files, or drag them onto the page.
Remi takes PDF, Word, Excel, CSV, text, code and image files, up to 50 MB each. Use **Folder** to group them.
**Check it worked:** select the document. In its details, **Status** reads **Ready** once Remi has read it.
Documents you upload are private until you share them. To share one with your workspace, select it, set its **Visibility** to **Open**, and select **Confirm**.
## Ask Remi about your documents [#ask-remi-about-your-documents]
Remi can search the documents you've added when it answers, and it cites its sources. To point it at particular documents:
* **One document:** select it in **Documents**, then **Chat about this document**.
* **Several documents:** select them in **Documents**, then **Chat with these**.
* **From a chat:** select the paperclip (**Add attachment**), then **Choose from documents**.
Then ask, for example:
```text
What does the Acme contract say about payment terms?
```
## Next [#next]
# Configure the CLI (/docs/cli-config)
> **Coming soon.** Remi CLI isn’t out yet.
Everything on this page is optional. Remi works with no configuration at all. Claude Code's files (`CLAUDE.md`, `.claude/commands`, `.claude/skills`, `.claude/agents`, `.mcp.json` and plugins) work as they are, so a project set up for Claude Code is ready for Remi.
| To | Write | Section |
| ------------------------------------------ | -------------------------------- | ------------------------------------------------------------------- |
| Tell Remi how your project works | `AGENTS.md` | [Tell Remi about your project](#tell-remi-about-your-project) |
| Keep a prompt you can run as `/name` | `.remi/commands/.md` | [Make your own commands](#make-your-own-commands) |
| Teach Remi a task it picks up when it fits | `.remi/skills//SKILL.md` | [Teach Remi a skill](#teach-remi-a-skill) |
| Hand big searches to a read-only helper | `.remi/agents/.md` | [Hand big searches to a subtask](#hand-big-searches-to-a-subtask) |
| Run a script at set moments | `hooks` in `.remi/settings.json` | [Run your scripts at set moments](#run-your-scripts-at-set-moments) |
| Give Remi another service's tools | `.mcp.json` | [Add MCP servers](#add-mcp-servers) |
| Bring several of these in one folder | `.remi/plugins//` | [Add plugins](#add-plugins) |
## Where your settings live [#where-your-settings-live]
| File | Applies to | Commit it? |
| --------------------------- | ----------------------------------------------------------------- | -------------------------- |
| `~/.remi/settings.json` | You, in every folder | No |
| `.remi/settings.json` | This project, for everyone | Yes |
| `.remi/settings.local.json` | This project, just you. "Don't ask again" answers are saved here. | No, add it to `.gitignore` |
When the files disagree on a single value, such as `model`, the later file in the table wins. Lists, such as permission rules, are combined.
```json
{
"model": "Remi Auto",
"permissions": {
"defaultMode": "default",
"allow": ["Bash(npm test:*)", "Bash(git diff:*)", "Edit(src/**)"],
"deny": ["Read(secrets/**)"],
"ask": ["Bash(git push:*)"]
},
"notifications": "bell",
"theme": "light"
}
```
* `notifications`: `bell` (the default) rings the terminal bell when Remi waits for you, and when a long turn finishes. `off` turns it off.
* `theme`: `dark` or `light`. Leave it out and Remi asks your terminal.
* `host`: `{ "enabled": false }` stops this folder taking messages from your phone or the web. See [Pick up anywhere](/docs/cli#pick-up-anywhere).
## Trust a folder [#trust-a-folder]
The first time you run `remi` in a folder, it asks whether you trust it. Say no and Remi quits. Your answer is saved, and trusting a folder also trusts everything inside it.
Anyone can commit a file to a repo. So a folder's own files that start programs, that Remi uses without you asking, or that loosen the rules wait until you trust the folder:
| The folder's own | Not trusted | Trusted |
| ----------------------------------------------------------- | ----------- | ------- |
| `AGENTS.md` and `CLAUDE.md` | Sent | Sent |
| MCP servers (`.mcp.json`, and `mcpServers` in its settings) | Not started | Started |
| Hooks and the status line | Not run | Run |
| Skills, agents and `/` commands | Not loaded | Loaded |
| Plugins in `.remi/plugins/`, with their hooks and servers | Not loaded | Loaded |
| Allow rules, `defaultMode` and extra folders | Ignored | Applied |
| Deny and ask rules | Applied | Applied |
Your own files in `~/.remi/` always count. Trusting a folder doesn't stop Remi asking before it changes files or runs commands: your mode and your rules decide that.
`remi -p` never asks. In a folder you haven't trusted, it runs as the "Not trusted" column says. To trust the folder for one run, in CI for example, set `REMI_TRUST_FOLDER=1`.
## Choose what runs without asking [#choose-what-runs-without-asking]
### Modes [#modes]
Press **Shift+Tab** in the app to change mode, use `--mode` for one run, or set `permissions.defaultMode` in your settings.
| Mode | In settings | What Remi does without asking |
| ------------ | -------------- | ---------------------------------------------------------------------------------------- |
| Default | `default` | Reads and searches. Asks before edits and commands. |
| Accept edits | `accept_edits` | Edits files. Asks before commands. |
| Plan | `plan` | Only reads. |
| Autopilot | `auto` | Edits files, and runs commands in a sandbox. Asks before what the sandbox can't contain. |
| Bypass | `bypass` | Never asks. Use it only where nothing can go wrong. |
**The Autopilot sandbox.** On macOS, and on Linux with `bwrap` installed, a command in Autopilot can read anything but can only write inside the project, temporary folders and tool caches, and can't reach the network. Remi still asks before:
* commands that need the network, such as installs, pushes and `curl`;
* commands that name a file that may hold secrets, such as `.env` or a key;
* deleting files, git commands that lose work, and running as another user;
* reaching outside the project folder;
* commands too complex for Remi to read safely.
To let the sandbox reach the network, set `"sandbox": { "network": true }` in your settings. On Windows, and on Linux without `bwrap`, there's no sandbox, so Autopilot asks before commands.
### Rules [#rules]
Rules say which tools run without asking (`allow`), which always ask (`ask`) and which never run (`deny`). They use Claude Code's syntax:
| Rule | Matches |
| --------------------------- | ------------------------------------- |
| `Bash(git status)` | Exactly that command |
| `Bash(npm test:*)` | That command, and anything after it |
| `Bash` | Every command |
| `Edit(src/**)` | Edits and new files under `src/` |
| `Read(.env)` | Reading `.env`, in any folder |
| `mcp__github` | Every tool of the `github` MCP server |
| `mcp__github__create_issue` | That one tool |
In the app, `/permissions` lists every rule in force and the file it comes from. To add one, use `/permissions allow`, `deny` or `ask` with the rule:
```text
/permissions allow Bash(npm test:*)
```
It's saved in `.remi/settings.local.json` and applies straight away. `/permissions remove` with the rule takes it out.
A few things to know:
* For `a && b` to run without asking, every part has to be allowed. A deny rule on any part blocks the whole command.
* Commands that only look, such as `ls`, `git status` and `git diff`, never ask. Where there's a sandbox, they run in one that can't write or reach the network.
* Edits to files that run things later, such as `.remi/`, `.claude/`, `.mcp.json`, `.git/hooks/` and `.vscode/`, always ask, unless a rule names them.
### Files that may hold secrets [#files-that-may-hold-secrets]
Remi doesn't read these unless an allow rule names them: `.env` and `.env.*` (but not templates such as `.env.example`), `.envrc`, `.dev.vars`, `*.pem`, `*.key`, `*.p12`, `*.pfx`, SSH keys, `.git/config`, `.npmrc`, `.netrc`, `.pypirc`, `*.tfvars` and `credentials*.json`. An `@` mention never attaches one, and searches skip them.
Before command output is sent to Remi, keys, tokens and passwords in it are replaced with `[redacted]`. Your terminal still shows the real output.
### Work in more than one folder [#work-in-more-than-one-folder]
Remi works in the folder you started in. To let it use another folder too, such as a sibling repo, start with `--add-dir`, or use `/add-dir` in the app:
```sh
remi --add-dir ../shared
```
The same rules apply in the other folder. To make it permanent, add `"permissions": { "additionalDirectories": ["../shared"] }` to your settings.
## Tell Remi about your project [#tell-remi-about-your-project]
`AGENTS.md` is where you tell Remi how a project works: how to build and test it, its conventions, and what to leave alone. Remi sends it with every message.
```markdown
# AGENTS.md
- Run `npm run check` before saying you're done. It runs the types, lint and tests.
- API types stay snake_case, as the server sends them.
- Don't edit files under `generated/`. Run `npm run codegen` instead.
```
* **Where Remi looks:** `AGENTS.md` (or `REMI.md`, or `CLAUDE.md`) in the project and in each folder between the repo's root and where you started. For notes that apply to every project, use `~/.remi/AGENTS.md`.
* **Write a first version:** run `/init` in the app.
* **Add a line:** type `# always use pnpm` in the app.
* **Edit it:** `/memory edit` opens the folder's file in your editor, and `/memory edit ~` opens yours. The next message reads it again.
* **See what's sent:** `/context` shows how full the conversation is, the instruction files, the skills, the agents and the tools. If it left a file out, it says why.
A project's instruction file must be a Markdown file inside its folder. If it links to a file elsewhere, or to a file that may hold secrets, Remi skips it.
## Make your own commands [#make-your-own-commands]
A command is a prompt you keep in a file and run by name. Save this as `.remi/commands/fix-issue.md`:
```markdown
---
description: Fix a GitHub issue
argument-hint:
---
Fix issue #$1. Read the issue, find the cause, fix it, and run the tests.
```
Then type `/fix-issue 42` in the app, or run `remi -p "/fix-issue 42"`. Remi sends the prompt with `42` in place of `$1`.
* **Where they're read:** `~/.remi/commands/` for yours, and `.remi/commands/` and `.claude/commands/` in the project. A file in a subfolder becomes `/folder:name`.
* **Arguments:** `$ARGUMENTS` is everything after the command, and `$1` to `$9` are the words one by one. A command that uses neither gets the arguments added at the end.
* A project's commands load only once you trust the folder.
## Teach Remi a skill [#teach-remi-a-skill]
A skill teaches Remi how to do a particular task, and Remi loads it when a request matches. It's a folder with a `SKILL.md`, in Claude Code's format. Save this as `.claude/skills/release-notes/SKILL.md`, next to a `template.md`:
```markdown
---
name: release-notes
description: Write release notes from the changes merged since the last release
---
List the pull requests merged since the last tag, then write the notes in template.md's shape.
```
Ask for release notes and Remi loads the skill before it starts. `/release-notes` runs it directly.
* **Where they're read:** `~/.remi/skills/` for yours, and `.claude/skills/` and `.remi/skills/` in the project.
* **What Remi can read:** the skill's instructions, and the files in its folder, such as `template.md`. Never anything outside it, and never a file that may hold secrets.
* **Who runs it:** add `disable-model-invocation: true` to keep a skill to `/name`, or `user-invocable: false` to keep it to Remi.
* A project's skills load only once you trust the folder. `/context` lists the skills Remi has.
## Hand big searches to a subtask [#hand-big-searches-to-a-subtask]
Some questions mean reading many files: "find every place that writes a session file". Remi can hand those to a subtask: a second Remi that can only read, does the searching in its own chat, and brings back just what it found. Your conversation doesn't fill up with every file it opened. Remi decides when to use one, or you can ask: "use a subtask to find every caller of `saveSession`".
A subtask only reads. Your deny rules and the files that may hold secrets apply inside it, and anything that would ask is refused. It stops after 15 minutes and counts towards your plan like any turn. To turn subtasks off, add `Task` to `permissions.deny`.
**Custom agents** give a subtask a name, instructions and fewer tools, in Claude Code's format. Save this as `.claude/agents/code-finder.md`:
```markdown
---
name: code-finder
description: Finds where something is implemented and explains how the pieces fit
tools: Read, Grep, Glob
---
Search the code for what you're asked about. Answer with the files and lines that matter, and a short explanation of how they connect.
```
Remi runs the one that fits, or the one you name: "ask code-finder where retries are handled". Agents live in `~/.remi/agents/`, and `.claude/agents/` or `.remi/agents/` in the project. `tools:` can only name read-only tools (`Read`, `Grep`, `Glob`, `LS` and `Skill`).
## Run your scripts at set moments [#run-your-scripts-at-set-moments]
Hooks are commands Remi runs at set moments, in Claude Code's format, so existing hooks work as they are. Add them to your settings:
```json
{
"hooks": {
"PostToolUse": [
{ "matcher": "Edit|Write", "hooks": [{ "type": "command", "command": "npx prettier --write ." }] }
]
}
}
```
* **When they run:** `SessionStart`, `UserPromptSubmit`, `PreToolUse`, `PostToolUse`, `Notification`, `Stop` and `SessionEnd`.
* **What they get:** the event as JSON on standard input.
* **What they can do:** exit with `0` to carry on. On `SessionStart` and `UserPromptSubmit`, what they print is added for Remi to read. Exit with `2` to block: the tool doesn't run, or the message isn't sent, and Remi is told why.
* **Where they run:** `sh` on macOS and Linux, and Git Bash on Windows when it's installed.
A project's hooks run only once you trust the folder.
## Add MCP servers [#add-mcp-servers]
MCP servers give Remi another service's tools, such as your issue tracker or a database.
### In your Remi account [#in-your-remi-account]
```sh
remi mcp add https://mcp.example.com/mcp
```
Use the server's MCP address from its own docs. The server is added to your Remi account, so it works in every Remi app: the web, your phone, Remi Desktop and here. If it needs a sign-in, your browser opens. Remi keeps the sign-in on its side, so it isn't stored on this computer.
`remi mcp list` and `/mcp` show your servers. `remi mcp remove` takes one out.
### On this computer [#on-this-computer]
Remi reads `.mcp.json` in the project, the same file Claude Code uses:
```json
{
"mcpServers": {
"github": {
"type": "http",
"url": "https://api.githubcopilot.com/mcp/",
"headers": { "Authorization": "Bearer ${GITHUB_TOKEN}" }
}
}
}
```
`${VAR}` is read from your environment, so keys don't go in the file. To add a server from the command line:
```sh
remi mcp add --scope user --transport http github https://api.githubcopilot.com/mcp/
```
`--scope user` keeps it in `~/.remi/mcp-servers.json`, for every project; Remi Desktop reads that file too. Servers that need a sign-in show "needs a sign-in" in `remi mcp list`: run `remi mcp login` with the server's name.
Remi asks before using an MCP tool, unless the server marks it read-only or a rule allows it. A project's own servers start only once you trust the folder.
## Add plugins [#add-plugins]
A plugin bundles skills, commands, agents, hooks and MCP servers in one folder, in Claude Code's format:
```text
deploy-tools/
├── .claude-plugin/plugin.json
├── commands/status.md
├── skills/deploy/SKILL.md
├── agents/reviewer.md
├── hooks/hooks.json
└── .mcp.json
```
Try one for a single run:
```sh
remi --plugin-dir ./deploy-tools
```
To keep it, put it in `~/.remi/plugins/deploy-tools/`. Each part is named after the plugin, such as `/deploy-tools:status`. In the app, `/plugin` lists what's loaded and anything left out, with why.
Remi loads plugins only from folders on your computer, not from marketplaces. A project's plugins in `.remi/plugins/` load only once you trust the folder.
## Change the status line [#change-the-status-line]
As in Claude Code, your own command can draw the line under the input box:
```json
{ "statusLine": { "type": "command", "command": "~/.remi/statusline.sh" } }
```
It gets the session as JSON on standard input, and the first line it prints replaces Remi's.
## Connect your editor [#connect-your-editor]
Zed, JetBrains IDEs, Neovim and Emacs can run Remi as their AI agent through `remi acp`. Your editor shows the chat, the changes and the permission requests. Remi works in the project the editor has open.
Sign in from a terminal first:
```sh
remi login
```
If your editor can't find `remi`, use the full path from `which remi` instead of `remi`.
Open Zed's settings with the **zed: open settings file** command, and add:
```json
{
"agent_servers": {
"Remi": {
"type": "custom",
"command": "remi",
"args": ["acp"],
"env": {}
}
}
}
```
Open the Agent Panel, select **+** and pick **Remi**.
In AI Assistant (2026.2 and later), open the AI Chat tool window, select the menu in the upper-right corner and choose **Add Custom Agent**. Then fill in:
```json
{
"agent_servers": {
"Remi": {
"command": "remi",
"args": ["acp"],
"env": {}
}
}
}
```
With [avante.nvim](https://github.com/yetone/avante.nvim):
```lua
require("avante").setup({
provider = "remi",
acp_providers = {
remi = { command = "remi", args = { "acp" } },
},
})
```
[CodeCompanion.nvim](https://codecompanion.olimorris.dev/configuration/adapters-acp) works too, with an ACP adapter that runs `remi acp`.
In Emacs, [agent-shell](https://github.com/xenodium/agent-shell) can run Remi through an agent config whose client runs `remi acp`, defined the way agent-shell defines its built-in agents.
Your editor's modes, model picker, `/` commands and `/undo` work as in the terminal. When your editor offers it, Remi edits its open buffers and runs commands in its terminal.
### Use Remi from another agent [#use-remi-from-another-agent]
`remi mcp serve` lets other agents ask Remi things over MCP, with your connected apps and web search. For Claude Code:
```sh
claude mcp add --transport stdio remi -- remi mcp serve
```
## Use Remi in scripts and CI [#use-remi-in-scripts-and-ci]
`remi -p` answers once and exits. See [Ask once, from a script](/docs/cli#ask-once-from-a-script) for the options.
Where nobody can sign in in a browser, use a token:
### Create a token [#create-a-token]
On your own computer, signed in:
```sh
remi token create --name ci
```
Copy the token it prints. `remi token list` shows your tokens, and `remi token revoke` with a token's id stops it working.
### Set it where Remi runs [#set-it-where-remi-runs]
Store the token as a secret in your CI, and make it available as `REMI_TOKEN`. Remi uses it instead of a sign-in.
### Trust the folder for the run [#trust-the-folder-for-the-run]
A CI checkout is a new folder each time. Set `REMI_TRUST_FOLDER=1` if the run needs the project's own skills, hooks or MCP servers.
## Environment variables [#environment-variables]
| Variable | What it does |
| ----------------------------- | ------------------------------------------------------------------------------------------------- |
| `REMI_TOKEN` | Use this token instead of a sign-in, for CI and scripts. |
| `REMI_TRUST_FOLDER=1` | Trust the folder for this run. |
| `REMI_HOME` | Where settings and sessions live. The default is `~/.remi`. |
| `REMI_CREDENTIALS_STORE=file` | Keep your sign-in in `~/.remi` instead of the system keychain. |
| `REMI_NO_UPDATE_CHECK=1` | Don't check for a new version when the app starts. It checks at most once a day, and never in CI. |
These change what the installer does:
| Variable | What it does |
| ----------------------- | ------------------------------------------------------ |
| `REMI_VERSION` | Install this version instead of the latest. |
| `REMI_CHANNEL=beta` | Install from the beta channel. |
| `REMI_INSTALL_DIR` | Install somewhere other than `~/.remi/bin`. |
| `REMI_NO_MODIFY_PATH=1` | Don't add Remi to your `PATH` in your shell's profile. |
Set them before the install command:
```sh
curl -fsSL https://remiapp.ai/install.sh | REMI_INSTALL_DIR=~/bin sh
```
# Remi CLI (/docs/cli)
> **Coming soon.** Remi CLI isn’t out yet.
Run `remi` in a project folder and ask for what you need. Remi reads the code, makes the change, runs the checks and tells you what it did. It asks before it changes anything, unless you tell it not to, and you can undo what it changed.
It's the same Remi as on the web, your phone and Remi Desktop. Your account, models, chats, inbox, workflows and connected apps come with you.
## Before you start [#before-you-start]
* **macOS**, on Apple silicon or Intel.
* **Windows**, on x64 or Arm64.
* **Linux**, on x64 or Arm64, including Alpine and other musl-based systems.
* A Remi account. [Sign up on the web](https://remiapp.ai) if you don't have one.
You don't need admin rights. Remi installs into `.remi/bin` in your home folder.
### Install [#install]
Open **Terminal** and paste:
```sh
curl -fsSL https://remiapp.ai/install.sh | sh
```
Open **PowerShell** and paste:
```powershell
irm https://remiapp.ai/install.ps1 | iex
```
If you see `'irm' is not recognized`, you're in Command Prompt. Open PowerShell and try again.
Open your terminal and paste:
```sh
curl -fsSL https://remiapp.ai/install.sh | sh
```
### Check the version [#check-the-version]
```sh
remi --version
```
You should see a version number, such as `0.1.0`. If your terminal says it can't find `remi`, open a new terminal window: the installer adds Remi to your `PATH`, and only new windows pick that up.
### Sign in [#sign-in]
```sh
remi login
```
Your browser opens remiapp.ai/device. Check that the code matches the one in your terminal, then select **Approve**. Over SSH, `remi login` shows a code instead: open remiapp.ai/device on any device and enter it there.
To sign in with a code sent to your email instead, run `remi login --email you@example.com`.
### Start Remi [#start-remi]
Go to a project folder and start Remi:
```sh
cd my-project
remi
```
The first time you run Remi in a folder, it asks whether you trust the folder. Say yes for your own projects. [Trust a folder](/docs/cli-config#trust-a-folder) explains what that allows.
Then ask a question, or ask for a change. Before Remi edits a file or runs a command, it shows you what it wants to do and waits for your yes.
## Check it worked [#check-it-worked]
```sh
remi whoami
```
This shows the email you're signed in with. For a fuller check, run `remi doctor`. It checks everything Remi depends on and tells you what to do about anything that's wrong.
## Work in a folder [#work-in-a-folder]
Type your request and press **Enter**. Remi can read, search, edit and create files in the folder, and run commands there. Each change shows as it happens.
* **Answer a request.** When Remi wants to edit a file or run a command, it shows what and waits. Choose **Yes**; or yes and don't ask again for that command in this folder (for an edit, accept edits for the rest of the session); or **No, and tell Remi what to do instead**.
* **Undo.** `/undo` puts back the files Remi changed in its last turn.
* **Stop.** Press **Esc** to stop Remi mid-answer. Press **Ctrl+C** twice to quit.
* **Send a file.** Type `@` and a path, such as `@src/app.ts`, to send that file with your message. To send a picture, paste it with **Ctrl+V**.
* **Run something yourself.** Start a line with `!`, such as `! npm test`. Remi sees the output with your next message.
* **Leave a note for next time.** Start a line with `#`, such as `# always use pnpm`. It's added to the folder's `AGENTS.md`, which Remi reads in every session.
* **Write more than one line.** Press `\` then **Enter**, or **Alt+Enter**.
### Choose how much Remi does without asking [#choose-how-much-remi-does-without-asking]
Press **Shift+Tab** to move between the modes. The current mode shows under the input box.
| Mode | What Remi does without asking |
| ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Default | Reads and searches. It asks before every edit and command. |
| Accept edits | Edits files. It still asks before commands. |
| Plan | Only reads, and answers with a plan. Nothing changes. |
| Autopilot | Edits files, and runs commands in a sandbox that can only write in the project and can't reach the network. It still asks before anything the sandbox can't contain, such as installing packages or touching files that may hold secrets. |
On Windows, and on Linux without `bwrap` installed, there's no sandbox, so Autopilot asks before commands. To start in a mode, use `remi --mode plan` (or `accept_edits`, `autopilot`). [Permissions](/docs/cli-config#choose-what-runs-without-asking) has the details, and how to allow particular commands.
### Commands in the app [#commands-in-the-app]
Type `/` to see them all. The ones you'll use most:
| Command | What it does |
| -------------- | ----------------------------------------------------------------------------------------------- |
| `/model` | Pick the model, from the models on your account. |
| `/mode` | Pick a mode. `/autopilot` switches straight to Autopilot. |
| `/undo` | Put back the files Remi changed in its last turn. |
| `/clear` | Start a new chat. |
| `/resume` | Pick up an earlier session in this folder. |
| `/context` | See what goes with each message: instructions, skills, tools, and how full the conversation is. |
| `/memory` | List the instruction files. `/memory edit` opens the folder's `AGENTS.md` in your editor. |
| `/answer` | Go through a form Remi asked you, one question at a time. |
| `/handoff` | Open this chat on the web or your phone. |
| `/permissions` | See and change what runs without asking. |
| `/mcp` | See your MCP servers and their tools. |
| `/plugin` | See the plugins loaded here. |
| `/inbox` | Your Remi inbox, as the bell shows it on every device. |
| `/workflows` | Your workflows, and what they did lately. |
| `/save` | Save an image, video or audio Remi just made into the folder. |
| `/copy` | Copy Remi's last answer. |
| `/export` | Copy the whole chat as Markdown, or save it to a file. |
| `/usage` | How much of your plan's allowance you've used. |
| `/init` | Write a first `AGENTS.md` for the project. |
| `/review` | Review your uncommitted changes. |
| `/help` | Every command and key. |
To pick up where you left off, run `remi --continue` for the last session in this folder, or `remi --resume` to choose one.
## Ask once, from a script [#ask-once-from-a-script]
`remi -p` answers once and exits, for scripts and automation:
```sh
remi -p "Summarise what changed since the last release"
```
* **For a program to read:** add `--output-format json` for one JSON result, or `--output-format stream-json` for a stream of events.
* **To let it act without asking:** add `--allow-tools` with the commands it may run, such as `--allow-tools "Bash(npm test:*),Edit"`.
* **To keep it in bounds:** `--max-turns 5` stops after five rounds of tool calls.
To run Remi where nobody can sign in, such as CI, create a token and set it as `REMI_TOKEN`:
```sh
remi token create --name ci
```
[Scripts and CI](/docs/cli-config#use-remi-in-scripts-and-ci) has the rest.
## Pick up anywhere [#pick-up-anywhere]
While `remi` is open in a folder, you can carry on that chat from your phone, the web or another computer. What you send from there runs here, in this folder, with this folder's rules. When Remi needs your permission, you can answer on your phone, but the terminal has the final say.
* `/handoff` opens the chat on the web or your phone.
* `/host off` stops taking messages from elsewhere for this session. `remi --no-host` starts without it.
## Your Remi account in the terminal [#your-remi-account-in-the-terminal]
| Command | What it shows |
| -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `remi inbox` | What came into your Remi inbox. Reading it here marks it read everywhere. |
| `remi workflows` | Your workflows and what ran lately. `remi workflows run ` runs one, and `pause` or `resume` work the same way. |
| `remi studio` | The designs and writing you made in Remi's studio. `remi studio export --pdf` saves one into this folder (also `--png`, `--pptx`, `--docx` or `--md`). |
| `remi models` | The models you can use. |
| `remi usage` | How much of your plan's allowance you've used. |
| `remi mcp add ` | Adds a hosted MCP server to your account, for every Remi app. [MCP servers](/docs/cli-config#add-mcp-servers) has more. |
## Use Remi from your editor [#use-remi-from-your-editor]
Zed, JetBrains IDEs, Neovim and Emacs can run Remi as their AI agent, through `remi acp`. Your editor shows the chat, the changes and the permission requests, and Remi works in the project the editor has open. [Connect your editor](/docs/cli-config#connect-your-editor) has the setup for each.
## Update or remove [#update-or-remove]
To update, run `remi update`. Remi also checks for a new version once a day and tells you when there is one.
To remove it, sign out with `remi logout`, then delete the program:
```sh
rm ~/.remi/bin/remi
```
```powershell
Remove-Item $HOME\.remi\bin\remi.exe
```
```sh
rm ~/.remi/bin/remi
```
Your settings are in the `.remi` folder in your home folder; delete it to remove them too. Your chats stay in your Remi account.
Set `REMI_VERSION` for a particular version, or `REMI_CHANNEL=beta` for the beta, before the install command:
```sh
curl -fsSL https://remiapp.ai/install.sh | REMI_CHANNEL=beta sh
```
The installer and `remi update` download Remi from Remi's release service and compare the file's SHA-256 checksum with the one the release lists. If they don't match, nothing is installed.
# Connect your apps and MCP servers (/docs/connect-apps)
Connect an app and Remi can use it from your chats, for example to find an email or add a calendar event. This page covers connecting apps on the web, at [remiapp.ai](https://remiapp.ai).
## Open Integrations [#open-integrations]
Select your email address at the bottom of the sidebar, then **Integrations**. The page has these sections:
* **Your own apps:** apps you added by their MCP server address.
* **Connected:** apps you've connected.
* **Available:** apps you can connect now.
* **Available to turn on:** apps an admin can switch on for your account. Only owners and admins see this section.
* **Coming soon:** apps that aren't ready yet.
Which apps you can connect depends on your account, so this page is the place to check. Use **Search integrations...** or the categories to find one.
## Connect an app [#connect-an-app]
1. Open **Integrations** and find the app under **Available**, for example Gmail, Google Calendar or Slack.
2. Select **Connect**.
3. A window opens. Sign in to the app there and allow Remi access. For an app that uses a key or password instead, Remi asks you for it: fill it in and select **Connect**.
**Check it worked:** the app moves to **Connected**.
If no window opens, your browser blocked the pop-up. Allow pop-ups for remiapp.ai and select **Connect** again.
## If the app you need isn't there [#if-the-app-you-need-isnt-there]
* **Members:** an admin turns integrations on for the whole account. Ask an owner or admin of your account to switch on the apps you need, then connect them.
* **Owners and admins:** under **Available to turn on**, select **Enable** on the app. To turn an app off for everyone, select **Disable** on its card, then **Turn off**.
* **Apps that are coming soon:** select **Notify me** to hear when one is ready. To ask for an app that isn't listed, select **Suggest an integration**.
* **Apps with an MCP server:** add the app by its address. See [Add an app by its MCP server address](#add-an-app-by-its-mcp-server-address).
## Choose what Remi may do with an app [#choose-what-remi-may-do-with-an-app]
Select a connected app's card to open it. Its **Tools** tab lists what Remi can do with the app, grouped as **Read**, **Write** and **Destructive**. Remi asks before any tool that changes something.
**Standing decisions**, on the same tab, lists the tools you allowed or blocked for good from a chat. Select **Revoke**, and Remi asks again next time.
[Approvals, Autopilot and pick up anywhere](/docs/approvals-autopilot) explains the choices Remi gives you when it asks.
## Add an app by its MCP server address [#add-an-app-by-its-mcp-server-address]
You can add any app that has an MCP server, by the server's address, even if the app isn't in the list. It's yours alone, and works in your chats on every device.
1. Open **Integrations**.
2. In **Your own apps**, select **Add by URL**.
3. Paste the address of the app's MCP server into **Server address**. The app's own docs give it, and it starts with `https://`, for example `https://mcp.example.com/mcp`. You can also fill in **Name (optional)**.
4. Select **Add**. If the app asks you to sign in, its sign-in page opens next. Sign in, and you come straight back to Remi.
**Check it worked:** the app is listed under **Your own apps** as **Connected**, with how many tools it has.
Remi keeps the address private, since some addresses include a key. Remi asks before it uses any tool from an app you added, unless the app marks that tool as read-only.
If Remi can't add the app, it says why:
| Message | What to do |
| ------------------------------------------------ | ------------------------------------------------------------------------------------------ |
| Enter the full address, starting with https\://. | Copy the whole address from the app's docs. |
| Remi only connects to public https addresses. | Use the server's public `https://` address. Remi can't reach servers on a private network. |
| That address didn't answer as an MCP server. | Check the address in the app's docs. |
| Remi couldn't reach that server. | Check the address and try again. |
| That server doesn't let Remi sign in to it. | The server doesn't accept new apps signing in, so Remi can't connect to it. |
| This sign-in has run out | A sign-in lasts 10 minutes and works once. Add the app again. |
To remove an app you added, select **Remove** beside it, then **Remove** again. Remi forgets its address and sign-in, and stops offering its tools in your chats.
You can also add a server from the terminal with `remi mcp add`, and it goes on the same account. [Add MCP servers](/docs/cli-config#add-mcp-servers) has the details, including servers for one project on your computer.
## Fix a connection [#fix-a-connection]
If an app's card says **Connection error**, **Connection expired** or **Reconnection required**, select **Reconnect** and sign in again.
To check that a connection works, open the app and select **Test connection** on its **Settings** tab.
## Disconnect an app [#disconnect-an-app]
1. Open **Integrations** and select the app's card.
2. On the **Settings** tab, under **Danger zone**, select **Disconnect**, then **Disconnect** again.
Remi's access to the app is removed, and Remi stops using its tools. Active workflows that use the app are paused: reconnect the app, then resume them. Your chats, and anything Remi already made from the app's data, stay where they are. You can reconnect at any time.
## Next [#next]
# Remi Desktop (/docs/desktop)
> **Coming soon.** Remi Desktop isn’t out yet.
## What it does [#what-it-does]
* **Your chats, in their own window.** The chats, projects and documents from the web, in an app you can keep open beside your work.
* **Remi in a folder.** Choose a folder and Remi can read, search and edit its files, and run commands there. It asks before it changes anything, unless you choose a mode that lets it. You can keep or undo each change.
* **Hold to talk.** Hold a key in any app, speak, and let go. Remi writes what you said where your cursor is.
* **Quick Ask.** Press a key in any app, type a question, and Remi answers in a new chat.
## Before you start [#before-you-start]
* **Mac:** macOS 12 or later, on Apple silicon or Intel.
* **Windows:** Windows 10 or later, 64-bit.
* **Linux:** a 64-bit computer. Remi Desktop comes as an AppImage, and as a .deb for Debian and Ubuntu.
* **A Remi account.** [Sign up on the web](https://remiapp.ai) if you don't have one. Without one, you can still work in a folder, with a model on your computer or your own API key.
* **A microphone**, if you want to use hold to talk.
## Download and install [#download-and-install]
1. Go to [remiapp.ai/download](https://remiapp.ai/download) and select **Download for Mac**.
2. Open the file you downloaded, and drag **Remi** into your **Applications** folder.
3. Open Remi from **Applications**.
If macOS says it can't check Remi for malicious software, see [Find your error](/docs/troubleshooting#installing).
1. Go to [remiapp.ai/download](https://remiapp.ai/download) and select **Download for Windows**. For an MSI installer instead, open **Other systems** under the button.
2. Open the installer and follow its steps. If Windows says "Windows protected your PC", select **More info**, then **Run anyway**.
3. Open Remi from the Start menu.
1. Go to [remiapp.ai/download](https://remiapp.ai/download) and select **Download for Linux**. For the .deb, open **Other systems** under the button.
2. For the AppImage, make it executable and run it:
```sh
chmod +x Remi_*_amd64.AppImage
./Remi_*_amd64.AppImage
```
For the .deb, install it with apt:
```sh
sudo apt install ./Remi_*_amd64.deb
```
## Sign in [#sign-in]
Open Remi Desktop and select **Sign in**.
Select **Continue in your browser**. Remi opens remiapp.ai, where you're probably signed in already.
Check that the page shows the same code as the app, then select **Approve**.
You can also enter your email in the app and type the 6-digit code Remi emails you. Passkeys don't work in Remi Desktop yet: use your authenticator app or a recovery code instead.
## Check it worked [#check-it-worked]
The chats you started on the web appear in the sidebar.
## Work in a folder [#work-in-a-folder]
1. Select **Work in a folder**, or press **⇧⌘N** on a Mac (**Ctrl+Shift+N** on Windows and Linux).
2. Select **Choose a folder…** and pick the folder.
3. Ask Remi to do something there.
When Remi wants to change a file or run a command, it shows you what it wants to do and waits. Allow it, say no, or tell Remi what to do instead. Each file Remi changed has **Keep** and **Undo**, and **Keep all** and **Undo all** cover every file at once.
### Choose how much Remi does without asking [#choose-how-much-remi-does-without-asking]
Each folder session has a **Mode** menu. **⇧⌘M** (**Ctrl+Shift+M**) switches to the next mode.
| Mode | What Remi does without asking |
| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Ask first** | Reads and searches. It asks before it edits a file or runs a command. |
| **Edit freely** | Edits files. Commands still need your OK. |
| **Plan only** | Reads and plans, but doesn't change anything. |
| **Autopilot** | Edits files, and runs commands in a sandbox that can only change this folder. It still asks before deleting, installing software, signing in, or pushing and publishing. |
New sessions start in **Ask first**. To change that, go to Settings › **Models and permissions** and choose under **New sessions start in**.
**Autopilot** is in the **Mode** menu once you turn on **Allow Autopilot** in Settings › **Models and permissions**. On Windows, and on Linux without bubblewrap (`bwrap`) installed, there's no sandbox, so Autopilot asks before each command. [What Autopilot always asks about in Remi Desktop](/docs/approvals-autopilot#what-autopilot-always-asks-about-in-remi-desktop) has the full list.
### Choose the model for folder sessions [#choose-the-model-for-folder-sessions]
In Settings › **Models and permissions**, **Model for folder sessions** offers:
* **Remi (your account):** Remi's models, through the account you signed in with.
* **On this computer:** Ollama, LM Studio or another OpenAI-compatible server.
* **Anthropic:** Claude models, with your own API key. The key goes into your system keychain.
## Hold to talk [#hold-to-talk]
1. Put your cursor where you want the words, such as an email or a document, in any app.
2. Hold **⌃⌥Space** on a Mac, or **Ctrl+Alt+Space** on Windows and Linux, and speak. A small indicator shows while Remi is listening.
3. Let go. Remi writes what you said where your cursor is.
Press **Esc** while Remi is listening to cancel. To paste your last dictation again, press **⌃⌘V** on a Mac, or **Ctrl+Alt+Shift+V** on Windows and Linux.
Dictation needs you signed in: what you say goes through your Remi account to be written down. The first time on a Mac, Remi asks for **Microphone** access, and for **Accessibility** so it can paste for you. Without Accessibility, Remi copies the text and you paste it.
If another app already uses the key, Settings says so. The mic in Remi's own message box still works: select it, or press **⌘D** (**Ctrl+D**).
Settings › **Voice** has the rest:
* **Tidy what you say:** **As I said it**, **Everyday** (the default), **Formal** or **Technical**, which keeps file names, commands and symbols as you said them.
* **Your words:** names and terms Remi spells your way.
* **Snippets:** say a phrase of two words or more, and Remi puts in the text you saved for it.
* **Type into other apps:** on unless you turn it off. Off, Remi copies the text for you to paste.
* **Also keep each dictation as a note:** off unless you turn it on. Notes stay on this computer.
* **Indicator:** a bar, an orb or a dot, and where it sits on your screen.
## Quick Ask [#quick-ask]
Press **⌥Space** on a Mac, or **Alt+Space** on Windows and Linux, in any app. Type your question and press **Enter**: Remi opens a new chat with it in its main window. Press **Esc** to close the box.
You can also choose **Quick Ask** from Remi's icon in the menu bar or system tray. If another app already uses the key, the menu item still works.
## Keyboard shortcuts [#keyboard-shortcuts]
[Keyboard shortcuts](/docs/troubleshooting#remi-desktop) lists every Remi Desktop shortcut, with the Mac keys and the Windows and Linux keys.
## Update or remove [#update-or-remove]
To update, download the latest version from [remiapp.ai/download](https://remiapp.ai/download) and install it as before.
To remove Remi Desktop:
* **Mac:** quit Remi, then drag it from **Applications** to the Bin.
* **Windows:** in **Settings** › **Apps**, find Remi and uninstall it.
* **Linux:** delete the AppImage, or remove the package with apt.
Your chats stay in your Remi account.
## Coming from the CLI? [#coming-from-the-cli]
Remi Desktop and the [Remi CLI](/docs/cli) use the same account and workspace. A terminal session stays in the CLI and a folder session in Remi Desktop, so use whichever suits the job.
# What Remi remembers (/docs/facts)
Remi remembers what you tell it, so you don't have to say it again in every chat. Each thing it remembers is a fact, such as "Works as a bookkeeper in Leeds" or "Our financial year ends in March".
## Personal facts and shared facts [#personal-facts-and-shared-facts]
* **Personal facts** are about you. Only you can see them, and Remi uses them only in your own chats.
* **Shared facts** are about your business, such as your clients, what you sell or when a return is due. Everyone on your account can see them and change them, and Remi uses them in everyone's chats.
A workspace and a project can also have their own facts, about the work kept there.
## How Remi learns a fact [#how-remi-learns-a-fact]
* **From your chats.** After each reply, Remi looks back over the last few messages for anything worth keeping, and saves it without asking. When it does, the message shows **Remi remembered 1 thing from this message**. Select it to see what Remi kept.
* **When you ask.** Say "remember that…" in a chat, and Remi saves it straight away.
* **When you add one yourself.** See [Add a fact](#add-a-fact).
* **From a web page.** With the [browser extension](/docs/browser-extension), select some text, right-click it and choose **Remi** › **Remember this**. Remi asks **Remember this?** first, then keeps it as a personal fact.
* **From a workflow.** A workflow can keep what it learns as a fact for the workspace it runs in.
There's no setting to stop Remi learning from your chats. If it keeps something you'd rather it didn't, [delete the fact](#delete-a-fact).
## How Remi uses facts [#how-remi-uses-facts]
With every message you send, Remi brings in up to 20 of the facts it has about you, your workspace, your account and the project you're in. Your pinned facts come first, up to 10 of them, then the 5 newest. The rest are the ones closest to what you're asking.
So a fact you've just added is used straight away, and a fact you pin is used in every chat.
## See your facts [#see-your-facts]
* **Your personal facts:** go to **Settings · Personal** › **Facts**, or choose **Personal facts** from the menu at the bottom of the sidebar.
* **Shared facts:** select **Documents** in the sidebar, then the **Facts** tab.
* **A project's facts:** open the project and select its **Facts** tab.
Pinned facts come first, then the ones changed most recently. Each fact is marked **Remi** if Remi learnt it, or **Manually added** if someone added it. To find one, type in **Search facts...**.
Go to **Settings** › **Personal data** › **Facts**. The phone shows your personal facts.
## Add a fact [#add-a-fact]
1. Open the facts you want to add to, as in [See your facts](#see-your-facts).
2. Select **Add fact**.
3. Type the fact and select **Save**.
1. Go to **Settings** › **Personal data** › **Facts**.
2. Type the fact in **Add a personal fact...** and select **Add fact**.
## Pin or change a fact [#pin-or-change-a-fact]
On the web, open the menu (⋯) on a fact.
* **Pin** makes sure Remi has the fact in every chat. Select **Unpin** to undo it.
* **Edit** lets you change the wording. Select **Save** when you're done.
You can also ask Remi in a chat to correct a fact it has.
## Delete a fact [#delete-a-fact]
1. Open the menu (⋯) on the fact and select **Delete**.
2. Select **Delete** again to confirm.
To delete several at once, tick the box on each one, then select the bin and confirm.
In **Settings** › **Personal data** › **Facts**, select the bin next to the fact. It's deleted straight away, with no confirmation.
Ask Remi to forget it, such as "Forget that I work in Leeds". Remi asks you to allow it before it deletes the fact.
A deleted fact is gone for good, and Remi stops using it. If you tell Remi the same thing again later, it may learn it again.
## Who can change which facts [#who-can-change-which-facts]
| Facts | Who can see and change them |
| ----------------- | ------------------------------------------------------------------------------------------ |
| Personal facts | Only you |
| Shared facts | Everyone on the account |
| A project's facts | Everyone who can open the project. Once a project is archived, its facts can't be changed. |
# Welcome to Remi (/docs)
Remi is a workspace you share with your team: chats, projects, documents, tasks and workflows, with an AI that works across all of them. Your workspace lives in the EU, and what you put in it is never used to train a model.
## Which app is for what [#which-app-is-for-what]
Every Remi app signs in to the same account. Chats on the web, phone and desktop share one list, and your documents and connected apps are there wherever you open Remi. A session in the Remi CLI or a Remi Desktop folder stays in that app, and you can steer it from another.
| App | What it’s for | Status |
| --- | --- | --- |
| Remi on the web | Chats, projects, documents and workflows at remiapp.ai. Nothing to install. | Available |
| Remi Desktop | Remi in a window of its own on your Mac, Windows PC or Linux computer, working in a folder when you let it. | Coming soon |
| Remi CLI | Remi in your terminal, working on the code in the folder you’re in. | Coming soon |
| Browser extension | A side panel that reads the page you’re on and saves what matters to Remi. | Coming soon |
| iPhone and Android | Your chats, tasks and documents when you’re away from your desk. | Coming soon |
| Remi on WhatsApp | Message Remi the way you’d message anyone, with your workspace behind every answer. | In testing |
| Remi on Telegram | The same Remi in Telegram, after WhatsApp. | Coming soon |
**Available** means anyone can use it today. **In testing** means a few people are using it. **Coming soon** means it isn't out yet.
## Start here [#start-here]
## Use these docs with an AI tool [#use-these-docs-with-an-ai-tool]
Every page has a **Copy Markdown** button and an **Open** menu, so you can paste the page into a chat or open it in another AI tool. For the whole site at once, point your tool at [llms.txt](/llms.txt) (a list of every page) or [llms-full.txt](/llms-full.txt) (every page in full).
# Install Remi and sign in (/docs/install)
Every app signs in to the same Remi account. Start on the web; the other apps pick up where you left off.
## On the web [#on-the-web]
There's nothing to install. Open [remiapp.ai](https://remiapp.ai) in an up-to-date browser and sign in.
### Sign in [#sign-in]
* **With your email:** enter your email and select **Continue**. Remi emails you a 6-digit code. Type it in. There's no password.
* **With Google:** select **Sign in with Google**.
If you've turned on [two-factor authentication](/docs/account#turn-on-two-factor-authentication), Remi then asks for your passkey or the code from your authenticator app.
## Remi Desktop [#remi-desktop]
> **Coming soon.** Remi Desktop isn’t out yet.
Remi Desktop is for Mac (macOS 12 or later), Windows (10 or later, 64-bit) and 64-bit Linux. Download it from [remiapp.ai/download](https://remiapp.ai/download), install it, open it, and select **Sign in**. To sign in through remiapp.ai, select **Continue in your browser**, check the page shows the same code as the app, and approve it. [Remi Desktop](/docs/desktop#download-and-install) has the steps for each computer.
## Remi CLI [#remi-cli]
> **Coming soon.** Remi CLI isn’t out yet.
Paste the command for your computer into a terminal. It installs Remi into `.remi/bin` in your home folder, so you don't need admin rights.
In **Terminal**:
```sh
curl -fsSL https://remiapp.ai/install.sh | sh
```
In **PowerShell**, not Command Prompt:
```powershell
irm https://remiapp.ai/install.ps1 | iex
```
In your terminal:
```sh
curl -fsSL https://remiapp.ai/install.sh | sh
```
Then run `remi login` to sign in. [Set up the Remi CLI](/docs/cli) has every step.
## Browser extension [#browser-extension]
> **Coming soon.** Browser extension isn’t out yet.
The extension adds a Remi side panel to Chrome, Edge, Brave and other Chromium browsers, and Firefox and Safari versions are on their way. You install it by hand from [remiapp.ai/apps/browser](https://remiapp.ai/apps/browser) until it's in the extension stores. [Browser extension](/docs/browser-extension) has the steps and everything it does.
## iPhone and Android [#iphone-and-android]
> **Coming soon.** iPhone and Android isn’t out yet.
App Store and Google Play: coming soon.
## WhatsApp [#whatsapp]
> **In testing.** Remi on WhatsApp is in testing with a few people.
Message Remi the way you'd message anyone, with your workspace behind every answer. To join the test, [write to the Remi team](https://remiapp.ai/contact).
## Telegram [#telegram]
> **Coming soon.** Remi on Telegram isn’t out yet.
## Check it worked [#check-it-worked]
Sign in on a second device. The chats you started on the web are there. Terminal and folder sessions stay in the app that runs them.
# Make Remi yours (/docs/make-remi-yours)
These settings are yours alone. They follow you into every workspace and account you use, and nobody else on your team sees them or is affected by them.
On the web, they're in **Settings · Personal**, under **Personalisation** and **Read-aloud voice**. Open the menu at the bottom of the sidebar, where your email is, to get there. On the phone, they're in **Settings**, under **Personalization** and **Voice**.
## Personalisation [#personalisation]
A choice you select saves straight away, and anything you type saves when you click away from the box. To clear a box, delete what's in it and click away. Remi takes your choices as guidance: it follows them unless they get in the way of what you've asked for in a chat.
### What do you do? [#what-do-you-do]
Type your job or your line of work, such as "Accountant" or "Marketing manager". Remi uses it to tailor its answers to the kind of work you do.
If you tell Remi what you do in a chat, it can update this for you. It asks you first.
### Response style [#response-style]
Choose how Remi structures its answers.
| Style | What it means |
| ------------ | ------------------------------------------------------------------------------------------------ |
| **Balanced** | A natural mix of detail and brevity. This is where you start. |
| **Concise** | Short and direct, just the essentials. Remi still keeps the structure of a plan or a comparison. |
| **Detailed** | Thorough, with examples, the edge cases and the reasons why. |
| **Academic** | Formal and precise. Remi cites its sources and defines technical terms. |
### Personality [#personality]
Choose up to five traits for how Remi talks to you, or none.
| Trait | What changes |
| ---------------- | ---------------------------------------------------------------------------- |
| **Friendly** | A warmer, more conversational tone. Remi greets you by name. |
| **Professional** | A plain, structured business register. |
| **Humorous** | Remi can be funny, with the occasional joke where it fits. |
| **Creative** | Remi offers angles you might not have considered, and may disagree with you. |
| **Direct** | Remi answers first and explains after, without a preamble. |
### Custom instructions [#custom-instructions]
Write anything you want Remi to know or follow every time, such as how you like numbers laid out or the context of your business. Remi reads your custom instructions with every message you send. They can be up to 1,500 characters long.
## Read-aloud voice [#read-aloud-voice]
### When Remi speaks [#when-remi-speaks]
Remi speaks when you send it a voice note: it answers with a voice note of its own, and you can show the transcript underneath. Dictating into the message box doesn't get a spoken answer, because it turns what you say into text before you send it.
### Choose a voice [#choose-a-voice]
Under **Read-aloud voice**, select a voice to use it. Featured voices come first, and each one says whether it's a male or female voice and what accent it has. To hear a voice before you choose, select its play button. The voices on offer depend on the language you use Remi in.
If you never choose one, Remi speaks with its first featured voice. To go back to it, select **Reset to default** under the voices, or select the voice you chose again.
On the phone, choose a voice under **Settings** › **Voice** › **Preferred voice**.
### Play spoken answers straight away [#play-spoken-answers-straight-away]
**Auto-play voice responses** plays Remi's spoken answer as soon as it's ready. It's on to start with.
* On the web, it's under **Read-aloud voice**, and it applies to remiapp.ai in any browser you sign in on.
* On the phone, it's under **Settings** › **Voice**, and each phone has its own.
## A different thing: your team's writing voice [#a-different-thing-your-teams-writing-voice]
The tone and style guide that Remi follows when it writes documents for your team is a separate setting, shared across a workspace. The settings on this page only change how Remi talks to you.
# Notifications (/docs/notifications)
Remi lets you know when it needs your OK, when it has finished something for you, and when someone on your team does something that involves you. Every notification goes to your inbox in Remi. Whether it also reaches your phone, your browser or your email is up to you.
## What Remi tells you about [#what-remi-tells-you-about]
On the web, each kind of notification has its own switch, named as it is in the table.
| Notification | When you get it |
| -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Chat responses** | Remi finishes a reply while you don't have that chat open. You don't get one when your last message was a voice note, because Remi answers it aloud. |
| **Approval needed** | Remi is waiting for your OK in a chat, because a folder on your computer or an app you've connected wants to do something that needs your permission. |
| **Reminder** | A reminder you set on a task comes due. |
| **Mention** | Someone mentions you in a comment. |
| **Comment** | Someone replies in a comment thread you've written in. |
| **Invitations received** | Someone invites you to join their account. You get this only if you already use Remi. |
| **Invitation accepted** | Someone accepts an invitation you sent. |
| **Member added to project** | Someone adds you to a project. |
| **Project archived** | Someone else archives a project you're in. |
| **Project deadline approaching** | A project you're in is due tomorrow. |
| **Project deadline reached** | A project you're in is due today. |
| **Workflow completed** | A workflow you made finishes a run. The notification shows the first line of the run's summary. |
| **Workflow failed** | A workflow you made fails, with the reason. |
| **Workflow auto-paused** | Remi pauses a workflow you made, after three failed runs in a row or because an app it uses was disconnected. When someone leaves the account, Remi pauses their workflows, and the account's admins get this for each one the whole workspace can see. |
### What's on to start with [#whats-on-to-start-with]
Until you change anything:
* Every notification arrives in your inbox.
* Every notification except **Invitation accepted** and **Project archived** also comes to your phone and your browser, once you've [turned notifications on there](#choose-what-reaches-you).
* Remi emails you about four: **Project deadline approaching**, **Project deadline reached**, **Workflow failed** and **Workflow auto-paused**.
## Where notifications show up [#where-notifications-show-up]
### Your inbox [#your-inbox]
On the web, the bell in the sidebar shows how many notifications you haven't read. Select it to see them. Select a notification to open what it's about, which also marks it read, or select **Mark all read**. The bell shows the notifications for the account you're in.
On the phone, the bell is at the top of the chat screen. In your inbox there, you can mark a notification read, swipe it to archive it, answer an approval, or mark them all read.
In Remi Desktop, the bell is in the status bar at the bottom of the window.
When you read a notification on one device, it shows as read on the others too. The web bell can take up to a minute to catch up.
### On your phone [#on-your-phone]
Push notifications are off on a phone until you turn them on there. When Remi asks for your OK, the notification has **Allow once** and **Deny** buttons, so you can answer without opening the app. The Remi app's icon shows how many notifications you haven't read.
You don't get a notification for the chat you're looking at.
### In your browser [#in-your-browser]
Once you've turned on browser notifications, remiapp.ai notifies you even when its tab is in the background or closed. Select a notification to open what it's about.
### In Remi Desktop [#in-remi-desktop]
Remi Desktop notifies you only when you aren't looking at it, and only about something you can't already see on screen. What it notifies you about is set on each computer, under **Settings** › **Notifications** › **On this computer**.
### In the browser extension [#in-the-browser-extension]
The [browser extension](/docs/browser-extension#notifications) shows your notifications while it's connected to Remi. If you've turned on browser notifications at remiapp.ai in the same browser, the extension leaves them to remiapp.ai, so nothing arrives twice.
### By email [#by-email]
A notification email has the notification and a **View in Remi** button.
## Choose what reaches you [#choose-what-reaches-you]
The switches for each kind of notification belong to your account, so a change on one device applies on all of them. The switch for whether a particular phone, browser or computer shows notifications at all belongs to that device.
Go to **Settings · Personal** › **Notifications**.
1. Turn on **Browser notifications** to get notifications in this browser. Your browser asks whether to allow them. If it says they're blocked, allow notifications for remiapp.ai in your browser's settings.
2. Under that, each kind of notification has a switch. Turning one off stops it reaching your phones and remiapp.ai's browser notifications. It still arrives in your inbox. Remi Desktop and the browser extension have their own switches.
3. **Newsletter** at the bottom is for tips and news about Remi, by email.
Go to **Settings** › **Notifications**.
1. Turn on **Push notifications**. Your phone asks whether to allow them. If it says notifications are turned off for Remi, turn them on for Remi in your phone's Settings.
2. Select **Notification preferences** to see a switch for each kind of notification. They're the same switches as on the web.
If you haven't turned push notifications on yet, Remi may ask **Want a nudge when Remi needs you?**. Select **Turn on** to do it from there.
Turning **Push notifications** off stops notifications reaching that phone. Your other phones aren't affected.
Go to **Settings** › **Notifications**.
* **On this computer** has switches for what Remi Desktop notifies you about: **Remi needs you**, **A reply is ready**, **A job finished or failed** and **News from your Remi account**. **Show a count on the app icon** shows how many folders are waiting for you. These switches apply to this computer only.
* **Your Remi account** has a row for each kind of notification. **Phone** is the same switch as on the web and the phone, and covers browser notifications too. **Email** chooses which notifications Remi emails you about, and this is the only place to change it.
In the extension's Settings, turn **Show Remi's notifications here** on or off. It's on to start with.
## Emails that always come [#emails-that-always-come]
Some emails aren't notifications, so these switches don't change them: your sign-in codes, invitations to join an account, and emails about your plan, your usage and your support requests.
## Quiet hours [#quiet-hours]
Remi doesn't have quiet hours or a daily summary. To pause notifications for a while, use Focus or Do Not Disturb on your phone or computer.
# Privacy and your data (/docs/privacy)
Your workspace lives in the EU, is encrypted, and is never used to train a model.
This page sums up Remi's privacy policy. The policy itself is what counts: read it in full at [remiapp.ai/privacy](https://remiapp.ai/privacy). Remi AI Ltd, registered in England and Wales, is the data controller.
## What Remi doesn't do with your data [#what-remi-doesnt-do-with-your-data]
* It doesn't use your data to train AI models.
* It doesn't sell your data.
* It doesn't profile you for advertising.
* It doesn't share your data with advertisers, data brokers or any other third parties beyond the service providers listed below.
## Where your data is stored [#where-your-data-is-stored]
All Remi-managed infrastructure is hosted in the EU.
| What | Where it's kept | Region |
| ---------------------------------------- | -------------------------------- | ------- |
| Account data, messages, events and usage | Neon PostgreSQL | EU only |
| Document files | Hetzner S3-compatible storage | EU only |
| Document vector embeddings | ChromaDB, self-hosted on Hetzner | EU only |
| Real-time session tokens | Ably | EU/UK |
## When your data leaves the EU [#when-your-data-leaves-the-eu]
When you send a message, your prompt and the relevant parts of your documents go to an AI provider, which writes the response. Remi's automatic routing puts EU providers first.
The only time your data leaves the EU is when a prompt goes to a US-based AI provider, and that happens only if your workspace is set up to use one. If you choose a US-based model yourself, your prompt is processed in the US. These transfers are covered by Standard Contractual Clauses (SCCs). Under their API terms, US-based providers don't keep your data to train models.
| AI provider | Data location | Used for |
| ------------------ | -------------- | -------------------------- |
| Mistral | EU | Responses |
| Remi-hosted models | EU | Responses |
| OpenRouter | US/EU (varies) | Routing to other providers |
| Anthropic (Claude) | US | Responses |
| OpenAI (GPT) | US | Responses |
| Google (Gemini) | US | Responses and embeddings |
## What Remi collects [#what-remi-collects]
* **Account data:** your email address, which you sign in with; your name, if you give it; and which accounts and workspaces you belong to.
* **Usage data:** chat messages and AI responses, the documents you upload and the text taken from them, facts and knowledge items, which integrations are connected, usage and cost records, sign-in times, session data, IP addresses, and browser and device information.
* **Technical data:** vector embeddings of your documents, which are mathematical representations rather than readable text, and event logs that record every action as an audit trail.
## Who handles your data [#who-handles-your-data]
Remi shares data only with the service providers it needs to run:
* **AI providers:** Mistral and Remi-hosted models, and, only if your workspace uses them, OpenRouter, Anthropic, OpenAI and Google. They write responses.
* **Neon:** database hosting.
* **Hetzner:** servers and file storage.
* **Ably:** real-time messaging.
* **Brave Search:** web results. It gets only the search query, not who you are.
* **Resend:** sends emails, such as your sign-in codes.
* **PostHog,** hosted in the EU: product analytics and session replay. Chat and document content is masked before anything is captured.
## Cookies and analytics [#cookies-and-analytics]
Remi uses essential cookies for signing in and keeping your session. It uses no advertising cookies.
PostHog, hosted in the EU, handles product analytics, and keeps its state in your browser's local storage rather than in cookies. Session replays record only layout and clicks: chat and document content is masked, and no text or input contents are recorded. To delete the analytics data linked to your account, write to [privacy@remiapp.ai](mailto:privacy@remiapp.ai).
## How long Remi keeps your data [#how-long-remi-keeps-your-data]
| Data | How long |
| ------------------------------ | ---------------------------------------------------------------------------------------------------- |
| Account data | While your account is active. Deleted within 30 days of closing it. |
| Chat messages and AI responses | While your account is active. Deleted within 30 days of closing it. |
| Documents and their embeddings | While your account is active. Deleted within 30 days of closing it, or when you delete the document. |
| Event logs | 12 months after you close your account, for the audit trail. Then deleted. |
| Billing records | 6 years, as UK tax law requires. |
## Your rights [#your-rights]
Under UK GDPR, you have the right to:
* see the personal data Remi holds about you;
* correct data that's wrong;
* have your data deleted, apart from what the law says Remi must keep;
* get your data in a machine-readable format to take elsewhere;
* restrict how Remi processes your data;
* object to processing that's based on Remi's legitimate interest;
* withdraw your consent, where processing is based on it.
To use any of them, email [privacy@remiapp.ai](mailto:privacy@remiapp.ai). Remi replies within 30 days.
If you're not happy with the answer, you can complain to the Information Commissioner's Office (ICO) at ico.org.uk or on 0303 123 1113.
## Close your account [#close-your-account]
The account's owner can ask the Remi team to delete the account and everything in it, from **Settings · Account**. [Delete your account](/docs/account#delete-your-account) has the steps. Nothing is deleted until the team replies, and then the retention times above apply.
## When the policy changes [#when-the-policy-changes]
Remi emails you about material changes to the policy at least 30 days before they take effect.
# Quickstart (/docs/quickstart)
Remi on the web works in any up-to-date browser, on a computer or a phone. Signing in with a new email creates your account, so signing up and signing in are the same steps.
### Sign up or sign in [#sign-up-or-sign-in]
Go to [remiapp.ai](https://remiapp.ai) and select **Start free**. If you're already signed in there, the button says **Open Remi** and takes you straight to Remi.
Enter your email and select **Continue**. Remi emails you a 6-digit code, from [hello@remiapp.ai](mailto:hello@remiapp.ai), with a subject like "123456 is your Remi login code". Type it in on the **Check your inbox** screen, or select the log-in button in the email. The code works for 10 minutes, and there's no password.
You can select **Sign in with Google** instead.
A new account starts on the Free plan, with no credit card needed. [Your plan](/docs/account#your-plan) compares the plans.
### Answer the setup questions [#answer-the-setup-questions]
The first time you sign in, Remi may show **Set up Remi**, three short steps:
1. **What should we call you?** Type your name and select **Continue**.
2. **What will you use Remi for?** Choose **For work**, **Personal**, **Work & personal** or **Just exploring**. Pick any suggestions that fit, or describe what you need, then select **Continue**.
3. **Where do you work?** asks for your company and what you do there. If you chose **Personal** or **Just exploring**, you see **Set up your space** instead, which asks for a workspace name. Select **Finish setup**.
Remi uses your answers to suit its suggestions to you. If it already has your name, as it does when you sign up with Google, it skips this.
### Ask something [#ask-something]
Type into the **Message Remi...** box at the bottom and press **Enter**. Press **Shift+Enter** for a new line. For example:
```text
Plan a 30-minute team meeting about next quarter's goals.
```
### Check it worked [#check-it-worked]
Remi's answer appears under your message as it's written. The chat is saved: you'll find it in the sidebar under **Recent chats**. To start another, select **New chat**.
## Work through Getting started [#work-through-getting-started]
A new chat shows a **Getting started** list above the message box, with six things to try. Select one and Remi starts it for you. Select **Skip** to leave one out.
| Item | What happens when you select it |
| ----------------------------------- | ------------------------------------------------------------------------------------------------ |
| **Upload a document** | Your file picker opens. Choose a PDF, spreadsheet or Word document to send to Remi. |
| **Tell Remi something to remember** | The message box fills in "Remember that ". Finish the sentence and send it. |
| **Create a project** | The message box fills in "Create a project called ". Add a name and send it. |
| **Set up a workflow** | The message box fills in "Set up a workflow that ". Say what it should do and when, and send it. |
| **Create a workspace** | The message box fills in "Create a workspace called ". Add a name and send it. |
| **Connect your tools** | The **Integrations** page opens, where you connect apps such as your email and calendar. |
An item moves to the done list once you've done it or skipped it, and the list goes away when all six are done.
Under it, the **Learn Remi** tiles cover projects, documents, data tables, facts, tasks and workflows. Select one and Remi puts a question or an example about it in the message box, ready to send.
## Next [#next]
# Team roles (/docs/team-roles)
Everyone on a Remi account has one of four roles: **Owner**, **Admin**, **Member** or **Viewer**. Your role decides what you can manage on the account. It doesn't let anyone read your chats.
You'll find your team in **Settings · Account** › **Team**. Open the menu at the bottom of the sidebar, where your email is, to get there.
## The four roles [#the-four-roles]
| Role | Who it's for |
| ---------- | ------------------------------------------------------------------------------------------------------------------------- |
| **Owner** | Full control of the account. The person who creates an account is its first owner, and an account can have more than one. |
| **Admin** | Runs the account day to day: the team, the plan and billing, and which apps the team can use. |
| **Member** | Uses Remi for their work: chats, documents, workspaces and projects. Everyone you invite joins as a member. |
| **Viewer** | Can open what's shared with them in the account, but can't start a chat or add a document. |
## What each role can do [#what-each-role-can-do]
| | Owner | Admin | Member | Viewer |
| ------------------------------------------------------------- | :---: | :---: | :----: | :----: |
| Start chats and add documents | ✓ | ✓ | ✓ | |
| Create workspaces and projects | ✓ | ✓ | ✓ | |
| Invite people and remove them | ✓ | ✓ | | |
| Make someone a Member or a Viewer | ✓ | ✓ | | |
| Make someone an Owner or an Admin | ✓ | | | |
| Change the plan, buy top-ups and change the card | ✓ | ✓ | | |
| See how much each person is using Remi | ✓ | ✓ | | |
| See the **Activity** log of who joined, left or changed roles | ✓ | ✓ | | |
| Turn an app on for the whole account | ✓ | ✓ | | |
| Rename the account | ✓ | ✓ | | |
| Ask for the account to be deleted | ✓ | | | |
Connecting an app to your own Remi is personal, whatever your role. [Connect apps](/docs/connect-apps) covers it.
## What stays private, whatever your role [#what-stays-private-whatever-your-role]
* **Your chats** are yours alone. Nobody else on the account can read them, owners and admins included.
* **Documents you upload** are private until you share them. An owner or admin can still open a private document from its link, but it isn't listed in their **Documents**.
* **Your personal facts** and your [personal settings](/docs/make-remi-yours) are yours alone. [What Remi remembers](/docs/facts) has more about facts.
* **A private workspace** is only for the people in it. Being an owner or admin doesn't let you see into one.
## Invite someone [#invite-someone]
Owners and admins can invite people.
1. Go to **Settings · Account** › **Team** and find **Invite a teammate**.
2. Enter their email and select **Send invite**.
They join with the Member role, and you can change it once they've joined. An invitation lasts 7 days. Until it's accepted, it's listed under **Pending invitations**, where you can send it again or revoke it.
## Change someone's role [#change-someones-role]
1. In **Settings · Account** › **Team**, find them under **Team members**.
2. Select their role, then choose the new one.
3. Check what the new role allows, then select **Change role**.
Owners can give anyone any role. Admins can change the role of Members and Viewers, to Member or Viewer. Nobody can change their own role, and the only owner of an account can't be given another role.
### Hand over the account [#hand-over-the-account]
There's no single step to hand over an account. Make the new person an **Owner** first, so the account has two. If you want to step down after that, ask them to change your role, because you can't change your own.
## Remove someone [#remove-someone]
Owners and admins can remove people.
1. In **Settings · Account** › **Team**, select the remove button next to the person.
2. Select **Remove** to confirm.
They lose access to the account straight away. The person who created the account can't be removed.
You can't remove yourself. To leave an account, ask an owner or admin to remove you.
## Roles in a project [#roles-in-a-project]
A project has its own team, with two roles: **admin** and **member**.
* Whoever creates a project is its admin. People added to it join as members.
* Project admins, and the account's owners and admins, can change the project, archive it and choose who's on its team.
* Everyone on the project can add tasks, documents and facts to it.
* A project always keeps at least one admin.
[Share a project with your team](/docs/chats-projects-documents#share-a-project-with-your-team) has the steps.
# Shortcuts, links and troubleshooting (/docs/troubleshooting)
## Find your error [#find-your-error]
Find what you see in the left column, then follow the fix.
### Signing in [#signing-in]
| What you see | What to do |
| ---------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| The email with your code doesn't arrive. | Check your spam or junk folder for an email from Remi ([hello@remiapp.ai](mailto:hello@remiapp.ai)) with a subject like "123456 is your Remi login code". Still nothing? After a minute, select **Resend code**. |
| "Invalid or expired code." | The code is mistyped, more than 10 minutes old, or not the newest one: each new code replaces the one before. Use the code from the newest email, or select **Resend code**. |
| "This login link has expired. Enter your email to get a new one." | The log-in button in a sign-in email works once, for 10 minutes. Enter your email again for a new code. |
| **Slow down a moment** | Too many codes were asked for or tried in a short time. Wait for the countdown, select **Dismiss**, then try again. |
| "Google sign-in doesn't work inside the Facebook or Instagram app." | Sign in with your email there, or open the page in your phone's browser and use Google. |
| "That code didn't work. Try again." on **Verify it's you** | Type the code your authenticator app shows now. Or select **Use a recovery code**. |
| "Couldn't verify with your passkey. Please try again." | Select **Try again**. Or select **Use your authenticator app instead** or **Use a recovery code**. |
| "That code wasn't found or has expired." on the page that approves a sign-in | Check the code in Remi Desktop or your terminal and type it again. If it's still refused, start the sign-in again from the app. |
| "Too many codes were tried. Wait 15 minutes, then try again." | Wait 15 minutes, then start the sign-in again from the app. |
### Installing [#installing]
| What you see | What to do |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `remi install: there's no Remi release on the stable channel at https://api.remiapp.ai/v1/releases/cli`, or on Windows "There's no Remi release on the stable channel at [https://api.remiapp.ai/v1/releases/cli](https://api.remiapp.ai/v1/releases/cli)" | The first Remi CLI release isn't published yet, so there's nothing to download. Nothing is wrong on your computer. Run the command again once the CLI is out. |
| `There's no Remi 1.2.3 at …` | The version you set in `REMI_VERSION` doesn't exist. Check the number, or unset `REMI_VERSION` to install the latest. |
| `Remi 1.2.3 has been withdrawn. Unset REMI_VERSION to install the latest.` | That version was taken back. Unset `REMI_VERSION` and run the command again. |
| On Windows: "Couldn't reach [https://api.remiapp.ai/v1/releases/cli/latest?channel=stable](https://api.remiapp.ai/v1/releases/cli/latest?channel=stable). Check your connection, or try again in a minute." | Check your connection and try again. Until the website's latest installer is live, the Windows installer also says this when the first release isn't published yet. |
| `'irm' is not recognized` | You're in Command Prompt. Open **PowerShell** and paste the command again. |
| Your terminal can't find `remi` after it installed. | Open a new terminal window. The installer adds Remi to your `PATH`, and only new windows pick that up. |
| macOS won't open Remi Desktop the first time, and says Apple can't check it for malicious software. | Open **System Settings** › **Privacy & Security**, scroll down, and select **Open Anyway** next to Remi. Then open Remi again. |
| Windows says "Windows protected your PC" when you open the Remi Desktop installer. | Select **More info**, then **Run anyway**. |
### Using Remi [#using-remi]
| What you see | What to do |
| ---------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| "Couldn't send that. You're offline, or the connection dropped." | Check your connection, then select **Try again**. |
| **You've used this month's allowance** | Your account has used its monthly allowance. An owner or admin can top up or upgrade from **Plan & billing**. Your message is still in the box, ready to send. |
| **Your storage is full** | Delete files you no longer need, or upgrade for more storage. Only an owner or admin can upgrade. |
[Account, security and plans](/docs/account#your-plan) explains allowances, top-ups and plans.
### Using the Remi CLI [#using-the-remi-cli]
| What you see | What to do |
| ----------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `You're not signed in. Run remi login.` | Run `remi login` and approve in your browser. In CI, set `REMI_TOKEN` instead ([Use Remi in scripts and CI](/docs/cli-config#use-remi-in-scripts-and-ci)). |
| `Remi refused REMI_TOKEN: it may be revoked, expired or mistyped.` | Make a new token with `remi token create`, or in **Settings** › **API tokens** on the web, and set it as `REMI_TOKEN`. Or unset `REMI_TOKEN` to use `remi login`. |
| `Your sign-in expired. Run remi login.` | Run `remi login` again. Remi CLI 0.1.0 also says this when you've never signed in, or when `REMI_TOKEN` was refused, so check those too. |
| `There's no Remi release on the stable channel yet.` from `remi update` | Nothing to do: there's nothing newer to install. Remi CLI 0.1.0 says `Couldn't check for updates (404)` here instead. |
### Check the Remi CLI [#check-the-remi-cli]
> **Coming soon.** Remi CLI isn’t out yet.
`remi doctor` checks everything the Remi CLI depends on, one line each: the version and updates, whether it can reach Remi, your sign-in, where your sign-in is kept, your shell, the Autopilot sandbox, git, ripgrep, whether you trust the folder, your instructions, your settings and your MCP servers.
```sh
remi doctor
```
A ✓ means fine, ! means optional or worth a look, and ✗ means broken. Each line says what to do, such as "not signed in: run remi login", or "nothing to update to" when no newer release is out. Add `--json` for output a program can read.
## Keyboard shortcuts [#keyboard-shortcuts]
### Remi on the web [#remi-on-the-web]
| Mac | Windows and Linux | What it does |
| --------------- | ----------------- | ------------------------------------------------------------------------------------------ |
| **⌘K** | **Ctrl+K** | Search everything: chats, projects, documents, data tables, facts, tasks and workflows. |
| **⌘B** | **Ctrl+B** | Show or hide the sidebar. While you're editing formatted text, it makes text bold instead. |
| **⌘D** | **Ctrl+D** | Start or stop dictating into the message box. |
| **Enter** | **Enter** | Send your message. |
| **Shift+Enter** | **Shift+Enter** | Start a new line. |
| **⌘Enter** | **Ctrl+Enter** | Send an edited question, after **Edit message**. |
| **Esc** | **Esc** | Stop editing a message. |
### Remi Desktop [#remi-desktop]
> **Coming soon.** Remi Desktop isn’t out yet.
To see the shortcuts in the app, press **⌘/** on a Mac, or **Ctrl+/** on Windows and Linux.
These work in any app, while Remi Desktop is running:
| Mac | Windows and Linux | What it does |
| ----------------- | ------------------------ | -------------------------------------------- |
| **⌥Space** | **Alt+Space** | Quick Ask |
| **⌃⌥Space**, held | **Ctrl+Alt+Space**, held | Hold to dictate anywhere: speak, then let go |
| **⌃⌘V** | **Ctrl+Alt+Shift+V** | Paste the last dictation again |
In the app:
| Mac | Windows and Linux | What it does |
| --------------- | ----------------- | ---------------------------- |
| **⌘N** | **Ctrl+N** | New Chat |
| **⇧⌘N** | **Ctrl+Shift+N** | Work in a folder |
| **⌘K** | **Ctrl+K** | Search chats |
| **⌘\\** | **Ctrl+\\** | Show or hide the sidebar |
| **⌘,** | **Ctrl+,** | Settings |
| **⌘/** | **Ctrl+/** | Show keyboard shortcuts |
| **Enter** | **Enter** | Send a message |
| **Shift+Enter** | **Shift+Enter** | New line |
| **Esc** | **Esc** | Stop Remi |
| **⌘D** | **Ctrl+D** | Dictate into the message box |
In a folder session:
| Mac | Windows and Linux | What it does |
| ----------- | -------------------- | -------------------------------- |
| **⌘O** | **Ctrl+O** | Choose a folder… |
| **⌘Enter** | **Ctrl+Enter** | Allow what Remi asks to do |
| **⇧⌘Enter** | **Ctrl+Shift+Enter** | Always allow it |
| **Esc** | **Esc** | Say no to what Remi asks |
| **⇧⌘M** | **Ctrl+Shift+M** | Switch the folder session's mode |
| **⇧⌘D** | **Ctrl+Shift+D** | Show or hide changed files |
| **⇧⌘E** | **Ctrl+Shift+E** | Show or hide files |
In Notes:
| Mac | Windows and Linux | What it does |
| ---------- | ----------------- | ----------------------- |
| **⇧⌘J** | **Ctrl+Shift+J** | Open Notes |
| **⌘D** | **Ctrl+D** | Dictate into the note |
| **⌘Enter** | **Ctrl+Enter** | Ask Remi about the note |
| **⇧⌘C** | **Ctrl+Shift+C** | Copy the note |
### Browser extension [#browser-extension]
> **Coming soon.** Browser extension isn’t out yet.
| Mac | Windows and Linux | What it does |
| ------- | ----------------- | ------------------------------------- |
| **⌥R** | **Alt+R** | Open Remi |
| **⌥⇧S** | **Alt+Shift+S** | Save this page to Remi |
| **⌥⇧D** | **Alt+Shift+D** | Dictate to Remi. Press again to stop. |
You can also ask from the address bar: type `remi`, a space and your question, then press **Enter**. Remi opens and sends it.
### Remi CLI [#remi-cli]
The CLI's keys are in [Work in a folder](/docs/cli#work-in-a-folder).
## Links that open Remi [#links-that-open-remi]
> **Coming soon.** Remi Desktop isn’t out yet.
These links open Remi Desktop. Each has a web version that opens the same thing at remiapp.ai.
| Link | What it opens | Web version |
| ----------------------- | ------------------------------------------------ | ------------------------------------ |
| `remi://` | Remi Desktop | `https://remiapp.ai` |
| `remi://chat/` | That chat in Remi Desktop, when you're signed in | `https://remiapp.ai/chats/` |
A chat's ID is the last part of its address on the web, after `/chats/`.
To open a new chat on the web with a question already typed in, link to `https://remiapp.ai/chats/new?prompt=` followed by your question, URL-encoded. Whoever opens the link sees the question in the message box, and sends it when they're ready.
## Contact the Remi team [#contact-the-remi-team]
Tell the team what you tried and what you saw.
* **Signed in:** choose **Help & support** from the menu at the bottom of the sidebar, then **Open support request**. Fill in the form and select **Send request**. Replies appear in the Support centre, and by email unless you untick **Notify me when Remi Support replies**.
* **Can't sign in:** use the form at [remiapp.ai/contact](https://remiapp.ai/contact), or email [hello@remiapp.ai](mailto:hello@remiapp.ai).
# What’s new (/docs/whats-new)
The changelog at [remiapp.ai/changelog](https://remiapp.ai/changelog) lists each release of each Remi app, and the changes made between releases, newest first.
* **Tabs:** **All** shows every app together. **Web**, **Desktop**, **CLI**, **Browser**, **Mobile** and **WhatsApp** show one app each. A change that applies to every app shows on every tab.
* **A release** has its date and version, a title, a few lines about it, and what's **New**, **Improved** and **Fixed**.
* **Changes between releases** are grouped by the day they went live, under **New**, **Improved** and **Fixed**.
* **Before an app's first release**, its tab says there's nothing there yet.
To open one app's tab, add `?product=` and the app to the address, such as [remiapp.ai/changelog?product=cli](https://remiapp.ai/changelog?product=cli). The other apps are `web`, `desktop`, `browser`, `mobile` and `whatsapp`.
To see which version of the Remi CLI you have, run `remi --version`. `remi update` gets the latest one.
# Workflows and tasks (/docs/workflows-tasks)
Tasks are your to-do list in Remi. Workflows are jobs Remi runs for you, on a schedule or when you say so. Both are on the web at [remiapp.ai](https://remiapp.ai).
## Add a task [#add-a-task]
1. Select **Tasks** in the sidebar.
2. Select **Create a task**, type what needs doing, and press **Enter**.
**Check it worked:** the task is in the list.
To add details, select the task. Its panel has **When**, **Priority**, **Project**, **Labels** and a **Checklist**.
You can also ask in a chat, for example "Create a task to send the Acme invoice on Friday". Remi asks first, unless you've already allowed it in that chat. The task's **Source** reads **From conversation**, and links back to the chat.
## Check off a task [#check-off-a-task]
Select the circle beside the task (**Mark complete**). The task may move out of the list you're looking at: it's under **Completed**. To reopen it, select the circle again.
## Plan your tasks [#plan-your-tasks]
The tabs sort your tasks by when they're due: **Today**, **Upcoming**, **Future** (tasks with no date yet) and **All tasks**.
To move a task, select **…** (**More options**) on it, then **Move to**, and pick **Today**, **Tomorrow**, **Next week**, **Pick a date** or **Future (no date)**. The same menu has **Organise**, to assign a project, add a label or set the priority, and **Edit task** and **Delete**.
## Set up a workflow [#set-up-a-workflow]
1. Select **Workflows** in the sidebar.
2. Under **What would you like to automate?**, describe the job in your own words. For example: "Every Monday at 9, summarise last week's tasks into a document".
3. Select **Draft it**. Remi drafts the steps, and you check them before anything runs.
4. Check each step. A step marked **Needs setup** needs something from you, such as the document or table it works on: select it and fill that in. To change the plan, ask in the box beside the steps.
5. Select **Activate** to switch the workflow on. Or select **Run a test** to try it once first, or **Save draft** to finish it later.
**Activate** and **Run a test** are ready once the workflow has a starter, at least one step, and no step marked **Needs setup**.
**Check it worked:** the workflow's page shows **Active**, and when it runs next.
Other ways to start a workflow:
* **From a template:** the **Workflows** page lists templates under **Start from a template**, such as one that reviews your open tasks and raises the overdue ones. Select one, then check its steps as above.
* **From a chat:** when you ask for something that repeats, Remi may suggest a workflow. Select **Set it up**.
* **From scratch:** select **New workflow**, choose a starter, then add steps.
## Choose when a workflow runs [#choose-when-a-workflow-runs]
A workflow's starter decides when it runs. When your description says when, such as "every Monday at 9", Remi sets the schedule as it drafts the steps. To set or change it yourself, in the builder, select the starter at the top of the steps (it reads **Choose a starter** until you pick one), and choose:
* **On a schedule:** choose how often it repeats (every day, week or month), on which days and at what time, then select **Use this schedule**. Times are in the time zone set in your settings.
* **When I say so:** it runs only when you run it.
## Run a workflow now [#run-a-workflow-now]
Open the workflow and select **Run now**. If the workflow isn't active, the button reads **Run a test** instead, and the workflow runs once as a test.
The run opens, and you can follow each step as it happens.
From the terminal, `remi workflows run ` runs one: see [Your Remi account in the terminal](/docs/cli#your-remi-account-in-the-terminal).
## Pause, change or remove a workflow [#pause-change-or-remove-a-workflow]
On the workflow's page:
* **Pause** stops it from running on its schedule. **Resume** starts it again.
* **Edit** opens the builder. Nothing changes until you select **Save**.
* **Settings** has the workflow's name and description, another workflow to run **After it finishes** or **If it fails**, its earlier **Versions** (select **Restore** to go back to one), and **Archive workflow** and **Delete workflow**. Deleting a workflow deletes its runs too, and can't be undone.
Remi pauses a workflow by itself when its last runs failed one after another, or when an app it uses is disconnected. The workflow's page says which. Fix the cause, then select **Resume**.
A workflow runs as the person who made it. If they leave the account, it's paused and can't run again.
## See what a workflow did [#see-what-a-workflow-did]
* **The workflow's page** lists its runs, with what each one did, such as "wrote “Weekly summary”". **Open run** shows the last run, and **All runs** shows the rest.
* **Activity**, on the **Workflows** page, lists every run across your workflows, newest first.
* **A run's page** shows each step and what it did. To ask about the run, type in the **Ask about this run…** box: what happened, why, or what to change next time. A failed run has **Run it again**.
## What a workflow does without asking [#what-a-workflow-does-without-asking]
A workflow runs when nobody's watching, so it can't stop to ask you. Activating it is your go-ahead for what its steps make: documents, data tables, tasks, projects, images, video and audio.
A run never:
* invites people or creates workspaces;
* changes your profile;
* creates, changes or starts workflows. Only a workflow's own **After it finishes** and **If it fails** settings start another one.
A run uses removal tools, such as deleting table rows, only when your own instructions for that step ask for a removal.
## Next [#next]