---
name: type-setup
description: Install Type, sign up or sign in, verify workspace access, and start building with the user.
---

# Set up Type

type.com (Type) runs your team's automations and agents. You describe the work, and Type writes the code and instructions, runs them with Claude or Codex on your team's shared connections, and records every run, with hosting, integrations, permissions, and model choice built in.

Follow this guide when the user asks you to set up Type. Installation alone is not completion: verify account and workspace access, load Type skills where supported, and help the user start their task. Reuse an existing installation and account where possible.

## Choose the right path

First, determine which kind of assistant you are:

- **You are Claude in the Claude app or web, or ChatGPT**: follow **Connect without a terminal** below. Do not ask the user to run installer commands for you.
- **You are Claude Code or Codex with shell access**: follow **CLI setup** below, starting at step 1.
- **You are Instinct or Muse**: install the Type CLI directly on the computer where you run. Follow **Install from Instinct or Muse** below, then the **CLI setup** steps.
- **You are Town**: follow the **Town** instructions under **Connect without a terminal**.
- **You are another assistant**: use **CLI setup** if you can run shell commands, or **Connect without a terminal** if your client supports remote MCP.

## Connect without a terminal (chat clients and assistants)

Type MCP is a hosted, OAuth-protected Model Context Protocol server. It does not need the Type CLI, a local process, or an API key. Once connected, you can read the user's workspace, manage Spaces and Channels, create documents and skills, build and publish Type Apps, run automations, and call connected integrations, all as the signed-in Type user.

Tell the user which steps apply to their client:

**Claude (claude.ai or the Claude desktop and mobile apps)**

1. Open the one-click installer: https://type.com/mcp/install
2. Claude asks the user to review the Type connector. Approve it.
3. Sign in to Type (or sign up if they do not have an account), select an organization, and approve the connection.

**ChatGPT**

1. Open the ChatGPT installer: https://type.com/mcp/install?client=chatgpt and sign in to Type (or sign up).
2. In ChatGPT, open **Settings → Security and login** and turn on **Developer mode**. Developer-mode availability depends on the user's ChatGPT account and workspace policy; if it is unavailable, they need a plan or workspace that allows it.
3. Open **Plugins**, add a new connection named **Type**, and paste the server URL shown on the installer page (`https://api.type.com/mcp`).
4. Choose **OAuth** as the authentication method, then approve Type access when prompted.

**Town**

Town supports custom MCP servers in routines. No terminal or Type CLI is needed.

1. In Town, open **Settings → MCP → Add Server**.
2. Enter **Type** as the name, `https://api.type.com/mcp` as the URL, and a description such as **Access my Type workspace**.
3. Complete Town's OAuth sign-in with the Type account and organization you want to use. Approve the connection when prompted.
4. Create or edit a Town routine. In its **MCP Servers** section, enable **Type** for that routine.
5. Run the routine and ask it to call `type_whoami`. Confirm the returned user and organization before saying the connection is ready. If authorization or the tool call fails, report the error; do not claim setup succeeded.

Town's custom MCP tools are enabled per routine, so adding the server in Settings alone does not make Type available to every Town conversation. [Town's MCP setup guide](https://www.town.com/docs/integrations/mcp-servers) has the current Town UI steps.

**Any other MCP client**

Configure a remote MCP server with this URL:

```text
https://api.type.com/mcp
```

The client must support remote Streamable HTTP MCP servers and OAuth. The server only accepts `POST` requests on that URL and publishes its OAuth metadata at `/.well-known/oauth-protected-resource/mcp`.

**After connecting**

Once the Type connector is available in the conversation, call `type_whoami` to confirm the signed-in user and organization, then continue to step 5, Get the user started. If the connector does not appear, ask the user to confirm the connection completed and is enabled for the current chat before retrying. Type MCP does not post messages or reply to threads; for those, use Type itself.

If the user's client supports neither a terminal nor MCP, link them to https://type.com/onboarding.

Full reference: https://docs.type.com/reference/type-mcp/

## Install from Instinct or Muse

Instinct and Muse can run the Type CLI on their own computer. Use your shell tool there to check for an existing installation and, if needed, run the official installer for that computer's operating system in CLI setup step 1. The computer can be remote from the user's device; the user does not need to install the CLI themselves. Then complete CLI setup steps 2–5 on that same computer, including sign-in and workspace verification. Report the actual installer or authentication error if a step fails.

The CLI's `install-agent-skills` command currently targets Claude Code and Codex only. For Instinct or Muse, use the verified CLI directly and consult `type-cli <command> --help` for current commands; do not claim that a Muse or Instinct skill was installed.

## CLI setup (Claude Code, Codex, Instinct, Muse, and other terminal agents)

### 1. Install the CLI

Check first:

```sh
type-cli --version
```

If it is missing, run the official installer for the operating system. On macOS or Linux:

```sh
curl -fsSL https://type.com/install.sh | sh
```

On Windows x64, use PowerShell:

```powershell
irm https://type.com/install.ps1 | iex
```

To update an existing standalone install, run `type-cli update`. Older Windows versions may reject that command; rerun the PowerShell installer, restart the terminal and Claude Code, and check `type-cli --version`. Windows binaries are also available directly at https://desktop.type.com/cli/type-cli-windows-x64.exe. Do not use the Unix shell installer or `install-shell` on Windows.

The installer sets up the CLI and supported agent skills. Follow its printed PATH instructions if the current shell cannot find `type-cli`, then verify `type-cli --version` again. If installation fails, report the actual error before continuing.

### 2. Check for an existing account

```sh
type-cli auth status --json
```

Read `authenticated`, not just `ok`: this command can return `ok: true` when signed out. If authenticated, skip signup and continue to step 4. If stored credentials are unusable, inspect the error; do not create another account to fix a network or permissions error.

For an existing account that needs login, go to step 3's normal login command. For a new account, ask in one message for their preferred signup method (email, Google, or Slack), email address, and workspace name. Ask only for missing details. Do not guess an email address or invent verification codes. Substitute the user's values in the commands below and quote them safely for the shell.

### 3. Sign up, then enable the CLI session for building

For **email signup**:

```sh
type-cli signup start --email "<email>" --name "<workspace name>" --json --no-input
```

Read the returned `status` and `nextStep`. If `status` is `code_sent`, ask the user for the six-digit code sent to their email, then run:

```sh
type-cli signup complete --code "<code>" --json --no-input
```

If the response says `ready_to_complete`, resume with `type-cli signup complete --json --no-input` without asking for another code. A mistyped code can be corrected by rerunning `signup complete --code`. For a transient completion failure, retry `signup complete` without the code to resume its saved checkpoint. For an expired code, rerun `signup start`.

For **Google or Slack signup**, use the chosen provider:

```sh
type-cli signup --provider google --email "<email>" --name "<workspace name>" --no-open --json --no-input
# For Slack, replace google with slack.
```

Keep the command running in a terminal session and show the user the printed sign-in URL. The provider-specific callback must open on the same machine as the CLI. For a remote CLI, use `type-cli signup --browser --email "<email>" --name "<workspace name>" --no-open --json --no-input` instead. Monitor the command until it finishes; do not ask the user to reply "done".

Check that signup completed successfully and retain the returned workspace identity and URL. Signup may reuse an existing workspace. If it reports multiple organizations, use normal login and ask which workspace the user wants.

**Signup credentials currently support identity, search, and thread reads only. To build or manage agents, apps, integrations, or skills, complete normal CLI login next:**

```sh
type-cli auth login --no-open
```

Keep this command running, show the user its verification URL and code, and wait for it to finish. Use the same account and intended workspace. Do not add `--json` here: the human-readable output supplies the sign-in instructions. If workspace selection is required, ask the user and follow the CLI's `--org` instructions. Do not log out or replace another working profile without the user's direction.

### 4. Verify access and load the agent skills

```sh
type-cli whoami --json
type-cli agents list --json --no-input
```

Confirm that the account and workspace match the user's intent. An empty agent list is fine. If credentials from an earlier signup are still limited, explain that normal CLI login is needed and run the login command in step 3. Other access-denied or service errors are not a reason to switch accounts or workspaces; report the error and resolve it before claiming setup is complete.

For Claude Code or Codex, ensure the Type skill is installed:

```sh
type-cli install-agent-skills --json
```

Inspect the reported installation results, then read `SKILL.md` at the returned skill path and the reference for the user's task. Do not assume that installing a skill makes it available in the current conversation without reading it. Instinct and Muse do not need this skill installation to use the CLI; continue with the verified `type-cli` commands on their computer. Use `type-cli <command> --help` when you need current flags. Never print stored credentials or upload unrelated local files.

### 5. Get the user started

Once verification succeeds, tell the user which workspace is ready and share its returned Type URL. Continue an existing requested task using the Type CLI and, where supported, the installed Type skill. Otherwise ask:

> Type is ready. What would you like to build: a shared agent, an automation, or an app?

Help them build their choice, verify the result, and return its Type link. Installing Type does not authorize unrelated publishing, external messages, or permission changes. Stay within the user's requested task.