> ## Documentation Index
> Fetch the complete documentation index at: https://docs.otamd.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Connect your coding tool

> Connect your coding agent with automatic terminal setup or guided IDE settings.

Open [Connect your coding tool](https://trylimitless.ai/app/connect) in the Limitless console. Choose your tool to see its setup instructions and current availability.

## Connect with a setup command

OpenCode, Claude Code, Codex, and Cline support a terminal command with browser approval. You need the selected tool and **Node.js 22 or newer** installed, plus owner or admin access to a Limitless workspace. For Cline, use Node.js **22 or 24**. Cursor and Cline's manual fallback use the [guided settings flow below](#manual-settings-for-cursor-or-cline), which does not require Node.js or a terminal command.

The automatic flows are enabled per deployment. The setup page shows which connections are available, including Cline's manual fallback when its command is disabled. Live model checks used **Claude Code 2.1.226** and **Codex CLI 0.162.1** on macOS; Windows setup has not been qualified.

1. Choose your tool in the console and copy its setup command.
2. Run it in your terminal. A browser window opens to Limitless; sign in if prompted.
3. Match the connection code in your browser with the one in your terminal.
4. Choose the workspace and project that should pay for requests, then select **Approve connection**.
5. Return to the terminal and wait for setup to finish. Follow its instructions to start a coding session.

Automatic setup configures a dedicated API key, the Limitless endpoint, and the available models compatible with your tool. DeepSeek Flash is the default. The console only offers automatic setup when that integration is enabled. Tools marked **Coming soon** do not yet have an available setup command.

### OpenCode

OpenCode uses its native provider login:

```sh theme={null}
opencode auth login https://trylimitless.ai
```

See the [OpenCode guide](https://docs.otamd.com/guides/opencode.md) for versions, configuration precedence, and troubleshooting.

### Claude Code

When enabled, run:

```sh theme={null}
curl -fsSL https://trylimitless.ai/connect/claude-code.mjs | node --input-type=module
```

Approve the connection in your browser. Start each session with `node ~/.config/limitless/claude-code/start.mjs` to refresh the compatible model picker before Claude Code starts. Plain `claude` uses the last configured list. Model picker configuration requires Claude Code 2.1.242 or newer.

Setup configures your **global Claude Code user settings** for Limitless, retaining unrelated settings and making a backup of the previous file. It respects `CLAUDE_CONFIG_DIR` when set; otherwise it uses `~/.claude/settings.json`. A local credential helper supplies the API key. The key is kept separately from the settings file and is not placed in the setup command or browser URL. Project or managed settings can override user settings.

The model is **GLM 5.3 Flash Unrestricted**, including requests made through Claude Code's small-model setting. This connection does not provide a Claude model.

### Codex CLI

When enabled, run:

```sh theme={null}
curl -fsSL https://trylimitless.ai/connect/codex.mjs | node --input-type=module
```

Codex setup requires **Codex CLI 0.163.0 or newer**. After browser approval, it creates a named Limitless profile, a live model-catalog URL, and a command-based credential helper. It respects `CODEX_HOME` and preserves your existing default configuration. Start a session with:

```sh theme={null}
codex --profile limitless
```

The profile disables hosted web search and multi-agent delegation (`multi_agent = false`). Text, function tools, and Codex's custom `apply_patch` tool are supported. Setup targets Codex CLI; desktop setup is not included in this flow.

### Cline extension

Install the Cline extension in your editor. When automatic setup is enabled, run the command shown on the connection page:

```sh theme={null}
curl -fsSL https://trylimitless.ai/connect/cline.mjs | node --input-type=module
```

After browser approval, setup uses [Cline's SDK](https://github.com/cline/cline/tree/main/sdk/packages/core) to add a named **Limitless** provider with your key, endpoint and the currently available Chat Completions models, including DeepSeek V4.1 Flash. Each model gets its own context/output limits, image support and current prices. Setup preserves your active provider selection. Use Cline's **Refresh Models** action to discover newly available IDs from the authenticated `/v1/models` source; review a newly discovered model's configuration against the connection page before use.

1. Wait for setup to finish, then reload the editor.
2. In Cline, choose the **Limitless** provider and your chosen model. On a fresh installation's welcome screen, first choose **Bring my own API key**, then **Limitless**.
3. If Plan and Act use separate models, choose Limitless in both modes.
4. Start a small task and check its request in Limitless **Activity**.

Use **Set up manually instead** on the connection page if you prefer copying settings or cannot run the command.

On October 16, the production setup command completed browser approval and automatic configuration for **Cline 4.1.24** using **`@cline/core` 0.0.93** on macOS. The existing isolated extension retained its Limitless selection and completed a live read/edit/test task against the hosted model. All four requests settled with no outstanding holds; the temporary connection key was revoked and its stored credentials cleared after testing. A separate earlier fresh-install test verified choosing Limitless and automatically filling the key, endpoint, model and limits. These checks qualify the browser-approval and SDK setup flow on the tested macOS installation.

## Manual settings for Cursor or Cline

Choose **Cursor**, or choose **Cline → Set up manually instead**, on the connection page. If Cline's command is disabled, its manual settings appear directly. Select the workspace and project in the console, then create a dedicated key or use an existing project key. New keys expire after **90 days**. Copy a newly created key before leaving the page; it cannot be displayed again later. Copy the base URL and model ID into your tool's settings as described below.

These guided flows use the tools' supported settings interfaces. They do not import settings automatically. On October 16, Cursor 3.12.30 accepted the saved key, endpoint and selected custom model, but its Free plan blocked the test prompt before inference. A paid-plan live editor qualification remains outstanding. Cline's automatic setup and live editor task passed as described above; manually pasting every provider field was not part of those tests.

### Cursor

Before creating a key, sign in to Cursor and check that your plan supports custom API keys. Cursor Free does not support this setup, even when a key is saved and the custom model appears selected. Our October 16 test was blocked with “Named models unavailable. Free plans can only use Auto.” Use a plan that allows custom models; your organization must also allow OpenAI API keys.

1. Open **Cursor Settings → Models → API Keys**.
2. Paste your Limitless key into **OpenAI API Key**, save it, and enable **Use OpenAI API Key**.
3. Enable **Override OpenAI Base URL** and set it to `https://trylimitless.ai/v1`.
4. Add and enable a custom model with the exact ID `deepseek-v4.1-flash-unrestricted`.
5. Restart Cursor, open a new chat, and select that custom model.
6. On the Limitless connection page, confirm that you selected the model, then choose **Open a test chat in Cursor**. Check the model picker and send the prefilled prompt. Look for the request in Limitless **Activity**.

The test button uses [Cursor’s supported prompt deeplink](https://cursor.com/docs/reference/deeplinks). It opens a prompt for you to review; it does not import your key or provider settings, select a model, or send a request automatically. A sent request uses your Limitless credits.

This follows [Cursor's custom-model setup instructions](https://forum.cursor.com/t/how-to-adjust-settings-for-custom-added-models/173253). Use the exact Limitless ID above, rather than a built-in GLM entry.

You need a [Cursor plan that supports custom API keys](https://forum.cursor.com/t/cant-switch-model/169806/10). Organization administrators can restrict personal keys or the OpenAI provider; see [Cursor's model access controls](https://cursor.com/docs/enterprise/model-and-integration-management).

Turn off the base URL override when returning to Cursor's built-in OpenAI models. Tab completion continues to use Cursor's own models. Cursor routes custom-key requests through its backend; its current [API-key guidance](https://cursor.com/help/models-and-usage/api-keys) explains billing and data handling. Limitless's 512K server context does not establish that Cursor uses the full window or supports every Agent feature. Cursor currently assumes a context limit for custom models and cannot detect or manually set our actual limit. Keep tasks small and start fresh chats for long work; see [Cursor’s context-window limitation](https://forum.cursor.com/t/does-max-mode-work-for-custom-api-openai-compatible-endpoint-models-what-decides-their-context-window/169950).

### Cline manual settings

1. Open the **Cline extension → Settings** and choose **OpenAI Compatible** as the API Provider.
2. Paste your Limitless key into the API-key field.
3. Set **Base URL** to `https://trylimitless.ai/v1` and choose a current **Model ID** on the connection page, including `deepseek-v4.1-flash-unrestricted`. Copy that model’s context/output limits and image-support setting.
4. Open **Model Configuration** and set the values below explicitly.
5. If you use separate models for Plan and Act, select and configure this model in both modes. Save the settings and start a new task.

| Model Configuration | Value |
| - | - |
| Context Window Size | `1048576` |
| Max Output Tokens | `32768` |
| Supports Images | On |

Cline's custom-model defaults can differ from these limits and may enable images. The table shows DeepSeek Flash settings. GLM 5.3 is text-only with a 1,000,000-token context; use the current connection page values. See [Cline's OpenAI Compatible guide](https://docs.cline.bot/provider-config/openai-compatible). A separate proxy, Cline CLI installation, or Node.js installation is not needed for these settings.

## Kilo

Kilo remains marked **Coming soon** until its connection is qualified. Use the [connection page](https://trylimitless.ai/app/connect) for current availability.

## Model discovery and switching

All setup paths use the same available-model catalog as the API, filtered by the protocol each tool uses. Newly registered models need no separate model-ID update in each installer. Models disabled in the deployment or awaiting required pricing are omitted.

| Tool | How to load current choices |
| - | - |
| OpenCode | Restart OpenCode, then use `/models`. Existing connections refresh without reconnecting. |
| Codex CLI | Run the setup command once to replace the old local catalog with a live `model_catalog_url`, then start `codex --profile limitless`. |
| Claude Code | Run setup once, then launch `node ~/.config/limitless/claude-code/start.mjs` to refresh the Messages-compatible picker each session. |
| Cline | Run setup to register all current models, reload the editor, then use **Refresh Models** for new IDs. |
| Cursor | Refresh the connection page, choose a model, then add its exact ID in Cursor. Cursor's custom-model list requires this manual step. |

The current models support Chat Completions, Messages and Responses. The connection page supplies the models and limits appropriate to each coding tool.

The connection page shows each model's current context/output limits and whether it accepts images. Coding-tool output budgets are capped at 32,768 tokens or the model's smaller limit. See [API compatibility](https://docs.otamd.com/guides/compatibility.md).

## Keys and usage

Each new key created by a connection flow is named after the tool. It expires after **90 days** and uses the selected workspace’s credits, spending caps, and request limits. It has normal project inference permissions; it is not limited to a single model. Reusing an existing key retains that key's current expiry and permissions.

Manage or revoke connection keys in [API keys](https://trylimitless.ai/app/api-keys). To replace a revoked or expired key, repeat your tool's connection flow and update its saved key.

Terminal connection codes expire after ten minutes. If automatic setup is interrupted after browser approval, check API keys and revoke any unused key before retrying.

Creating a key does not confirm that an IDE is configured. Send a request from your tool and check [Activity](https://trylimitless.ai/app/activity) for its outcome. Connecting does not start or reserve model capacity. The selected model must be available to accept requests.

## Other OpenAI-compatible tools

For tools with a custom OpenAI-compatible provider setting, create a project API key and use:

| Setting | Value |
| - | - |
| Base URL | `https://trylimitless.ai/v1` |
| API key | Your Limitless project key |
| Model | `deepseek-v4.1-flash-unrestricted` |

Check that your tool supports **Chat Completions**, streaming, and function tools. A custom base URL alone does not guarantee compatibility with every API feature. See [Compatibility](https://docs.otamd.com/guides/compatibility.md).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.