# Engines and sign-in

> Choose what powers the agent, sign in from inside the app, and learn which subscription or API key works where.

Source: https://graspable.dev/docs/engines-and-sign-in

Open **Settings → AI for the agent**. You choose one option and sign in right there. You need only one.

| Option | What you sign in with | Runs |
|---|---|---|
| Graspable agent | A ChatGPT or Claude subscription, an API key, a local model, or nothing: it can run on Credits | Graspable's own agent |
| Claude Code | A Claude subscription (Pro or Max) | Anthropic's Claude Code on your computer |
| Codex CLI | The ChatGPT login of the Codex CLI | OpenAI's Codex on your computer. Shown only if the Codex CLI is installed |

Only the selected option shows its sign-in. All three edit the same project, show the same run panel and go through the same checks.

## Graspable agent

### Sign in with ChatGPT

1. Select **Graspable agent**.
2. Choose **Sign in with ChatGPT**. Your browser opens.
3. Finish signing in there. The Settings page updates by itself and shows "Signed in with ChatGPT".

If the browser flow does not work, choose **Not working? Use a code instead**. The app shows a code to enter on the page that opened.

This uses your ChatGPT plan through OpenAI's Codex sign-in. OpenAI tolerates other apps using it but does not officially support them. If it stops working, switch to an API key.

### Sign in with Claude (experimental)

1. Select **Graspable agent**.
2. In **Claude subscription**, sign in with Claude. If needed, choose **Install Claude Code** first.
3. Finish in the browser, then choose **Use Claude with the Graspable agent**. An existing Claude sign-in works too.
4. Pick a model in the account row, or beside the prompt in a project.

Graspable keeps its own tools, approvals, edit history and editing workflow. Model requests use the official, unmodified Claude connection on this computer. Graspable does not copy its sign-in credentials. The separate **Claude Code** option still runs Claude Code’s own agent. Some Claude models require reasoning; their account disables **Off** and asks you to choose **Low**, **Medium** or **High** if Off was saved earlier.

Usage follows your Claude subscription and Agent SDK allowance. Extra usage depends on your Claude account settings; this does not promise unlimited or free requests. Available models also depend on that account. The subscription model picker does not show API token prices as subscription charges. The run’s dollar counter is marked **est.**: it uses API prices to enforce your budget limit and does not report a subscription bill.

This option runs locally. Moving its project to the cloud blocks the run until you explicitly choose another account; Graspable does not silently replace it with an API key. API-key or custom-provider overrides in the local Claude environment are rejected for this option.

### On Credits, with no AI account of your own

1. Sign in to your Graspable account in **Settings**.
2. Under **Graspable agent**, choose **Use the Graspable agent on Credits**.

The agent then runs on Graspable's AI account, and each request costs [Credits](https://graspable.dev/docs/credits.md) by what it used: 10 Credits for every dollar the model costs. A new account has 6 Credits to try it. Settings shows the price of the chosen model, and you can choose any other model that can use tools there. Your own AI accounts keep working beside it and stay free.

Requests go through Graspable to the model's provider. Graspable keeps only counts for them: tokens and Credits.

### Use an API key

1. Under **Graspable agent**, open **Use an API key, or pay with crypto** (or **Add an API key, or pay with crypto**).
2. Pick a provider and a model.
3. Paste the key and choose **Add**. **Get a key** opens the provider's key page.

The providers are Anthropic (Claude), OpenAI, OpenRouter, xAI, Groq, Mistral, Google Gemini, Vercel AI Gateway and Venice.

Keys are stored in your computer's keychain and sent only to the agent running on your computer.

An API key is billed per use by the provider. That is separate from, and on top of, any ChatGPT or Claude subscription.

### Venice

[Venice](https://venice.ai) runs open and frontier models. The Graspable agent can use it with your Venice account, or with no account at all.

#### With your Venice account

Pick **Venice** in the form above and paste a key from venice.ai (**Settings → API**). The key uses whatever your account has, in the order Venice spends it:

1. **Today's allowance**, if you stake DIEM at Venice: one dollar a day for each DIEM staked. It renews at 00:00 UTC and what is unused does not carry over.
2. **Plan credits**, if your Venice plan includes them.
3. **What you paid in**, with a card or with crypto.

Nothing has to be set up in Graspable for this: a key from an account that stakes or subscribes is spent that way by Venice itself. The account's row in Settings shows what is left of each, and **Refresh** reads it again. When nothing is left, a request is refused before it starts and says when the allowance renews.

When you make the key at venice.ai, you can give it a spending limit per day. That is a good idea for a key you hand to any app.

#### Paid with crypto, with no Venice account (experimental)

This is new and has been tried less than the rest. Start with a small amount.

Pick **Venice, paid with crypto (experimental)** and choose **Create the agent's hot wallet**.

1. Graspable makes a new wallet for the agent on this computer. It is yours: its key is kept in your keychain and you can show it at any time. It is a hot wallet (the key is on this computer, not in a hardware wallet), separate from your personal wallets, which Graspable never asks for. Keep in it only what you would let the agent spend.
2. Send **USDC on the Base network** to the address shown (**Copy address**), from an exchange or your own wallet. Other coins and other networks will not arrive.
3. Type an amount and choose **Add to the Venice balance**, then confirm. This sends that much USDC from the agent's wallet to Venice and cannot be taken back. The smallest amount is the one Venice names, $5 at the time of writing.
4. Requests are then charged against that balance, at Venice's price for the model you picked. The row shows what is in the wallet and what is left at Venice; **Refresh** reads both again.

What to know:

- Treat it like money in an app. Send what you plan to use, not savings.
- **Show the wallet's key** shows the key so you can keep a copy or move what is left with another wallet app. Whoever has the key can spend what is in the wallet.
- **Remove** deletes the key from this computer. Anything still in the wallet or in its Venice balance can then no longer be reached, so save the key first.
- When the balance runs out, the run stops and says so. Add to the balance and send the request again.
- The wallet stays on this computer. It cannot pay for a [Cloud Agent](https://graspable.dev/docs/cloud-agents.md); use a Venice API key there.
- Graspable takes nothing from these payments and never holds your money. They go from the agent's wallet to Venice.

### Routstr, paid with bitcoin (experimental)

[Routstr](https://routstr.com) is a network of servers ("nodes"), run by different people, that sell AI models for bitcoin. There is no account. This is new in Graspable and has been tried less than the rest: start with a small amount.

1. Pick **Routstr, paid with bitcoin (experimental)** in the form above.
2. Choose a node. Graspable lists nodes that have announced themselves and answer right now; **Another node…** takes an address you type. Then choose a model. Prices are shown in sats per million tokens, and differ from node to node.
3. Type an amount in sats and choose **Get an invoice**. Scan the QR code with a Lightning wallet, or copy the invoice into one, and pay it.
4. When the node sees the payment, the account appears by itself, with that balance. Requests are charged against it.

The row then shows the balance. **Get an invoice** there adds to it. **Withdraw what is left** takes the balance out: to a Lightning address if you give one, otherwise as a Cashu token that you paste into a Cashu wallet.

What to know:

- **A node is someone's server, and it holds your balance.** Graspable checks that a listed node really announced itself and answers, not that the people behind it are honest. Pay what you plan to use, and withdraw the rest.
- The invoice is remembered until the node says what became of it. If you pay and close the app, open Settings again and the account is set up then. **Forget this invoice** is only for an invoice you did not pay.
- A Cashu token from a withdrawal is the money itself. Claim it in a wallet right away. While it is unclaimed, **Show the last withdrawal again** asks the node for it again.
- **Remove** deletes the key of the balance from this computer. Withdraw first.
- **To change node**, add another Routstr account with the other node: an account cannot be moved, because its balance is held by the node it was paid to. You can keep several and pick which one the agent uses.

#### Confidential mode (experimental)

Some nodes offer a confidential mode. With an ordinary node, the node passes your request on to a model provider, so it could read your requests and the answers, change what comes back, or bill for a dearer model than it used. In confidential mode the agent holds an encrypted connection with the provider itself, and the node only relays it:

- the node cannot read your requests or the answers, and cannot change them, tool calls included;
- the model and the token limit are proven to be the ones you asked for;
- you pay for the usage the provider itself reported, on a receipt the node signs, and the agent checks all of it before a request counts as done.

No special hardware is trusted: it rests on the provider's own certificate and on cryptography. The method is [Juraj Bednar's](https://juraj.bednar.io/en/blog-en/2026/10/10/confidential-inference-on-routstr-without-trusted-hardware/), and Graspable uses his open-source client for it.

Where a node offers it, a **Confidential mode** switch appears under the account's balance. Switching it on pins the node's signing key and the provider it names; if either changes later, requests stop until you switch it off and on again.

What it costs you:

- **Speed and data.** Every request is a session of its own: about 28 MB of traffic and around fifteen seconds before the first word. A long run makes many requests.
- **A larger balance in reserve.** While a request runs, the node sets aside the cost of a full context for the model, and releases what was not used.
- **Answers up to 32,768 tokens**, and requests up to 8 MB.

What it does not hide: which model you use, when, and how long your requests and answers are. If a request cannot be made confidentially, it is not made at all. The method is new and has not had an outside review, so do not rely on it where a flaw would hurt you.
- Graspable takes nothing from these payments and never holds your money. You pay the node from your own wallet.

**Confidential images.** When your node offers image generation, select its Routstr account with Confidential mode switched on and ask the agent to list its image models. The list comes from the node's signed offer and includes the available quality tiers, their image-count limits and their prices in sats. Ask for an image, choose a tier, and approve the quoted price before generation starts. This is charged to your Routstr balance, separately from Graspable Credits and the agent's USDC wallet. Every generation needs your approval. Work without asking refuses these purchases.

The node can see the image model, quality tier, count and request length. It cannot read your prompt or the generated image. The model provider sees both. Successful images use a fixed price and a signed receipt; there is no token-usage charge. Before you approve, the quote shows both the expected price and the maximum failed-session charge. A failed or interrupted request can still cost sats. The agent saves verified WebP images in a new folder under `public/assets/`; it never replaces an existing folder. The images become ordinary project assets that you and the agent can use and edit. No prompt or payment receipt is added to that public folder. Review your images before publishing a project, since assets under `public/` are published with it.

Generation takes a fresh encrypted session, with roughly 23 MB of setup traffic before the image downloads. Requests time out after eight minutes, and image sizes are bounded. If verification or saving fails, check the project files before approving a new attempt; a provider may already have charged for a completed generation. If the provider returns incomplete images or a response that disagrees with the approved request, those images are not saved; any verified charge is still recorded. There is no unencrypted retry.

Confidential mode requires a node that supplies the current signed request rules and session authentication. Older or malformed offers are refused before a request starts.

If a request stops with **"API key USD spend limit exceeded"**, this can be a limit on the node operator's upstream provider key even when your Routstr balance still has sats. Contact the node operator or choose another provider. Adding to your balance or creating another balance key may not resolve it.

### Use a local or custom model

In the same form, pick **Custom / local (OpenAI-compatible)**. Enter the address and the model name. The key is optional.

This works with any OpenAI-compatible chat endpoint, such as Ollama (`http://127.0.0.1:11434/v1`), LM Studio, vLLM or a gateway.

You can add more than one account. Choose **Use this** on another to switch.

## Claude Code

1. Select **Claude Code**.
2. If it is not installed, choose **Install Claude Code**. This takes about a minute.
3. Choose **Sign in with Claude**. Your browser opens. If the page shows a code, paste it into the field in Settings.

Graspable runs your own, unmodified Claude Code. It never reads or copies your Claude sign-in.

If your Claude Code is set up to use an API key or an Anthropic Console account, Settings shows a warning that usage is billed per use and not to your subscription.

## Codex CLI

This option appears only when the Codex CLI is installed on your computer. Choose **Sign in with ChatGPT** under it.

You do not need it to use a ChatGPT subscription. The Graspable agent signs in with ChatGPT directly.

Codex runs commands inside its own sandbox without asking you. See [Approvals and safety](https://graspable.dev/docs/approvals-and-safety.md).

## A different AI for one project

**Settings → AI for the agent** sets the default for every project. To use something else in one project, open the project and choose it in the list above the prompt. The choice is kept for that project. Choose **Default** to follow Settings again.

## Reasoning

**Reasoning**, on the same page, sets how long the Graspable agent thinks before each step: **Off**, **Low**, **Medium** (the default) or **High**. More reasoning means better decisions on hard requests, and slower and costlier runs. The thinking is shown in the run panel as it streams. Claude Code and the Codex CLI decide this on their own; Claude Code does not show its reasoning text.

In a [cloud project](https://graspable.dev/docs/cloud-agents.md) only API key accounts can be chosen. If your default cannot run in the cloud, Graspable usually uses your first API key account and says so under the list. A Claude subscription choice stays blocked until you explicitly choose another account.

## Which subscription works where

| You have | Use |
|---|---|
| ChatGPT subscription | **Graspable agent** with **Sign in with ChatGPT** |
| Claude subscription | **Graspable agent → Claude subscription** (experimental), or **Claude Code** |
| Anthropic API key | **Graspable agent** |
| Any other provider's API key | **Graspable agent** |
| A Venice account, with staked DIEM or a Venice plan | **Graspable agent** with a **Venice** key |
| Crypto, and no account anywhere | **Graspable agent** with **Venice, paid with crypto** or **Routstr, paid with bitcoin** (both experimental) |
| A model on your own computer | **Graspable agent** with **Custom / local** |

Claude subscription requests use the official Claude connection. An Anthropic API key remains a separate, per-use option.

Signing in with Google or GitHub Copilot to power the agent is not offered.

## Choosing a model

Each option has a **Model** menu. Open it and type to search: every word you type must be in the model's name. Each row shows the model's name, how much text it can hold at once, what a million tokens cost to read and to write, and whether it reasons or reads pictures. Above the list you can narrow it to one maker, to models that reason or read pictures, and order it by newest, cheapest or largest.

Where the list comes from:

- **OpenRouter**: OpenRouter's own list, so a model is there the day OpenRouter adds it.
- **The Graspable agent on Credits**: every OpenRouter model that can use tools and has a price. Graspable's own picks are marked and come first. Prices are shown in Credits.
- **Claude subscription under Graspable agent**: the bundled Claude model catalog. A listed model is a candidate, not a guarantee that your account can use it.
- **Other API keys and the ChatGPT sign-in**: a public catalog of each provider's models.
- **Venice and Routstr**: Venice's list, or the node's.
- **Claude Code and the Codex CLI**: the tool installed on your computer. **Default** means whatever that tool is set to.

### For one project

Above the prompt in a project, next to **AI**, the same menu changes the model for that project alone. Settings keeps the default for the others.

## Keeping the lists current

Graspable keeps the lists on your computer and shows them at once. Each time it starts, it asks every source again in the background, so a model released yesterday is in the menu today without a new version of Graspable. **Refresh model list** at the top of the section asks again right away.

At the same time Graspable checks whether Claude Code and the Codex CLI on your computer are their newest versions, because a newer one can bring new models. When one is behind, its option says so and offers **Update**, which runs the tool's own updater. Nothing is updated without that click.

## Signing out

- Graspable agent: **Sign out** next to the ChatGPT row, or **Remove** next to a key.
- Claude subscription under Graspable agent: **Remove** removes the choice from Graspable. To end the shared Claude sign-in too, use **Sign out** under **Claude Code**.
- Claude Code and Codex CLI: **Sign out** under the option.

A project that runs in the cloud needs the Graspable agent with an API key. See [Cloud agents](https://graspable.dev/docs/cloud-agents.md).
