An AI agent is more than a chat box. It can work through a task, use tools, read the context you give it, and return with a result. But every agent still needs an AI model to decide what to do next.

That creates two separate layers:

The agent interface and workflow: where you describe the task, provide files or context, review the work, and control what the agent can do.
The model and inference: the AI model that processes each request and generates the next response or action.

Crux provides the first layer: a personal AI assistant interface that works across your desktop, files, apps, and workflow. For the second layer, Crux gives you options. You can bring an API key, connect a supported subscription, use a supported local model, or begin with the free models shown in the app.

That flexibility is the point of BYOK.

What BYOK means

BYOK stands for Bring Your Own Key. An API key is a secret credential issued by a model provider. It authorizes software such as Crux to use that provider's API on your account.

The usual setup is simple:

Create an account with a supported AI provider.
Create an API key in that provider's dashboard.
Add the key in Crux Settings → Keys.
Choose one of the available models in Crux and start a task.

The provider controls its model availability, rates, usage limits, and billing. Crux supplies the interface in which you select and use that model as part of your assistant.

An API key is not the same thing as a consumer chat subscription. Paying for a provider's chat product does not automatically include API usage. Crux does, however, separately support connecting certain existing subscriptions. The app currently exposes subscription connections for ChatGPT, GitHub Copilot, and Grok, with only the models made available by each subscription.

Why BYOK matters more for agents than for chat

In a normal chatbot, one message may lead to one answer. An agent can take several model turns to complete one request: it may inspect information, call a tool, evaluate the result, and continue. The model therefore affects more than writing style. It can affect capability, speed, context limits, and cost across the whole task.

BYOK gives you control over that choice. You might use one provider for a difficult task, another for quick everyday work, or a local model when its capabilities fit the job. If a provider changes its models or pricing, you can choose another supported option without changing the Crux interface or the way you organize your work.

BYOK does not mean every model will behave identically. Models differ in tool use, vision, reasoning, and other capabilities. Crux shows the providers and models available to your setup so you can select an appropriate one.

What Crux adds

BYOK on its own is only a credential. Crux turns that credential into a usable agent experience.

Inside Crux, you can connect providers from one settings interface, see the models available to you, and switch the selected model from the model picker. The same assistant interface can then use that model while working with the desktop, files, apps, and context you choose to provide.

Crux currently has dedicated key connections for OpenAI, Anthropic, Google, xAI, OpenRouter, and opencode, along with a broader provider catalog. The exact model list is determined by the connected provider and can change over time. Crux also supports local endpoints such as Ollama for compatible models running on your own hardware. Local-model features depend on what the selected model supports; for example, not every local model supports tools or vision.

This separation gives you a stable place to work while keeping the model layer replaceable. Crux is the interface and agent environment; the selected provider or local runtime supplies the inference.

You can try Crux without bringing a key

BYOK is an option, not a requirement for the first conversation.

In a local Crux session, the model picker includes an opencode (Free) group with keyless, cost-zero models when they are available from opencode. This gives you some free model inference through the Crux interface without first adding an API key or payment method. The available free models are supplied by opencode, so their names, limits, and availability may change.

You can also connect a compatible local endpoint such as Ollama. That route does not require a cloud-model API key, although running a model locally uses your own computer's resources and requires a local model setup.

These options make it possible to learn the Crux interface first. If you later need a different model, higher limits, or provider-specific capabilities, you can add your own key or connect a supported subscription.

Who pays for what?

It helps to keep the two layers separate:

You get Crux for the assistant interface and product experience.
With BYOK, your chosen provider meters API inference under your account and applies its own pricing and limits.
With a supported connected subscription, access is limited to the models and terms that subscription makes available.
With opencode (Free), the listed keyless models are cost-zero at the time they are surfaced in Crux, subject to opencode's availability and limits.
With a local model, inference runs on your own compatible hardware.

Crux does not make every route equivalent, and it does not turn a paid provider model into a free one. What it does is put these routes behind one model picker and one agent interface, so you can choose the arrangement that fits your work.

A practical way to begin

If you are new to AI agents, start with a free model in the local Crux app and give the assistant a small, real task. Once you understand the workflow, compare other models based on the capabilities you need. Add an API key only when you want to use that provider's API, or connect one of the subscriptions Crux explicitly supports.

Keep every API key private. Treat it like a password, set provider-side spending limits where available, and review usage in the provider's own dashboard.

BYOK is ultimately about keeping the agent experience and the model supply separate. Crux gives you the interface for doing the work. You decide which supported model powers it—and you can start with free inference before deciding whether you need anything else.

See Crux and download the app.