Cloud LLM Models - Agentic

What "Cloud LLM" Means

Cloud LLM (Hosted API) sends your requests to a third-party AI provider's servers over the network — Anthropic, OpenAI, Google, DeepSeek, Cohere, Groq, or OpenRouter. Unlike Ollama, In-Browser Models, or Local CLI, no model runs on your machine or in your browser tab; the provider's own infrastructure does the generation and streams the result back.

Providers are grouped here by architecture: Direct providers serve their own models from their own infrastructure; Proxy / Router and Serverless providers run open models (like Llama or Mixtral) on managed infrastructure; Aggregator providers (like OpenRouter) route to many providers behind one API.

Where to configure it

Go to Settings → Agentic → Writer Engine and select Cloud LLM (Hosted API). Pick a provider and model from the list below. See Agentic AI Settings for the full settings reference, and Ollama Integration, Local Language Models, or In-Browser Models for engines that don't require a cloud API key.

Anthropic — Direct

Anthropic's own Claude family, called directly against Anthropic's API:

Model	Type	Best for
`Claude Sonnet 4.6`	Direct	Balanced default — strong reasoning and writing quality at moderate cost.
`Claude Opus 4.7`	Direct	Anthropic's most capable model for the hardest reasoning and analysis tasks.
`Claude Haiku 4.5`	Direct	Fastest and cheapest Claude model for lightweight, high-volume tasks.

OpenAI — Direct / Serverless

Model	Type	Best for
`GPT-4o`	Direct	General-purpose flagship model with strong multimodal support.
`GPT-4o mini`	Direct	Cheaper, faster GPT-4o variant for everyday tasks.
`o3-mini`	Serverless	Reasoning-focused model for step-by-step logic and math.

Google AI Studio — Direct

Called directly against Google's own API — notable for aggressive pricing and very large context windows:

Model	Type	Best for
`Gemini 2.5 Pro`	Direct	Google's most capable model — large context window, strong reasoning.
`Gemini 2.0 Flash`	Direct	Fast and inexpensive — calling it directly here is significantly cheaper than routing through an aggregator like OpenRouter.

DeepSeek — Direct

DeepSeek's own models, called directly — widely regarded as the strongest cost/performance ratio in the current market:

Model	Type	Best for
`DeepSeek-V3`	Direct	General-purpose chat and everyday tasks at very low cost.
`DeepSeek-R1`	Direct	Advanced reasoning and coding — includes an explicit "thinking" step.

Cohere — Proxy / Router

Model	Type	Best for
`Command R7B`	Proxy / Router	Lightweight Cohere model for retrieval-augmented and enterprise tasks.
`Command R+`	Proxy / Router	Cohere's larger model for more complex retrieval and multi-step tasks.

Groq — Serverless

Runs open models (Llama, Mixtral) on Groq's custom LPU hardware — the first choice for anyone who wants open-source models at record-breaking token-per-second speed:

Model	Type	Best for
`Llama 3.3 70B (Groq)`	Serverless	Meta's Llama 3.3 at Groq's very high inference speed.
`Mixtral 8x22B (Groq)`	Serverless	Mistral's mixture-of-experts model, also at Groq speed.

OpenRouter — Aggregator

Routes to many underlying providers behind one API — convenient for trying multiple models without separate API keys, at a small markup versus calling providers directly:

Model	Type	Best for
`Llama 3.3 70B`	Aggregator	Open-weight model via OpenRouter's routing.
`Gemini 2.0 Flash`	Aggregator	Available here for convenience, but calling Google AI Studio directly (above) is cheaper.
`Mistral 7B`	Serverless	Small, fast open model for lightweight tasks.

Choosing a Provider by Architecture

Direct

Anthropic, OpenAI, Google AI Studio, DeepSeek — call the provider's own API directly. Lowest latency and cost for that provider's models; requires that provider's own API key.

Proxy / Router & Serverless

Cohere, Groq — managed infrastructure running either the provider's own models (Cohere) or open models on specialized hardware (Groq).

Aggregator

OpenRouter — one API key, many providers. Convenient for experimentation, but usually carries a small markup over calling a provider directly.

Tip: avoid paying the aggregator markup

If a model is available both directly (e.g. Google AI Studio's Gemini 2.0 Flash) and through OpenRouter, calling it directly is normally cheaper and faster — use the aggregator mainly for models that don't have their own direct listing here.

Selecting a Provider

1. Settings → Agentic

→

2. Writer Engine → Cloud LLM (Hosted API)

→

3. Pick a provider

→

4. Pick a model

Each provider requires its own API key configured on the server side — see Agentic AI Settings for where credentials are managed.

FAQ

Do I need a separate API key for each provider?

Yes. Each provider group (Anthropic, OpenAI, Google AI Studio, DeepSeek, Cohere, Groq, OpenRouter) requires its own API key configured on the server. OpenRouter is the exception in spirit — one OpenRouter key gives access to many underlying models, but it's still a separate key from calling those providers directly.

Why would I use OpenRouter instead of calling a provider directly?

Mainly convenience — one API key covers many models you'd otherwise need separate accounts for. The tradeoff is a small per-token markup and slightly higher latency versus a direct call.

What's the difference between this and Ollama or In-Browser Models?

Cloud LLM sends your data to a third-party provider's servers for processing. Ollama and In-Browser Models keep everything on your own machine or browser tab — see Ollama Integration and In-Browser Models for the local alternatives.

Which provider is cheapest?

As of this writing, DeepSeek and Google's Gemini 2.0 Flash are among the most cost-effective direct options; Groq is cost-effective specifically for open-weight models at very high speed.