Testkube AI Configuration Reference

This document provides a comprehensive reference for enabling and configuring Testkube AI functionality, including the AI Assistant, AI Agents, AI Agent Triggers, and related features.

Upcoming default change for on-prem installations

The AI service calls OpenAI-compatible providers through Chat Completions (/v1/chat/completions) unless a model needs the Responses API (/v1/responses). A later release will make responses the default for every model. To keep your current behaviour across upgrades, set inference.defaults.apiMode: chat_completions now. See API Mode for details, the list of models that already require the Responses API, and examples.

Cloud Control Plane Users

For users of the Testkube Cloud Control Plane, enabling AI functionality is straightforward:

Enable AI Assistant

The Testkube AI Assistant is disabled by default for new organizations.

Who can enable: Organization Owner or Admin

How to enable:

Via the Initial AI Assistant Prompt: When you first access the AI Assistant, an initial prompt is displayed with action buttons that allow you to either enable the feature or keep it disabled.
Through Organization Settings: Navigate to Organization Settings → Product Features tab and toggle AI Assistant on.

Once enabled, the AI Assistant, AI Agents, and AI Agent Triggers will be available in your Testkube Dashboard.

Custom Models

In addition to the platform default model, you can add your own models directly from the Dashboard to make additional models available for AI Chats. See Configuring AI Models for details.

Default LLM and Model

The default LLM used by AI functionality is OpenAI's GPT-5.2.

For Cloud installations, the platform default model is managed by Testkube. You can add additional models via Custom Models in the Dashboard.

For On-Prem installations, you can configure your own OpenAI API Key or use a different LLM/model as described in the On-Prem Users section below.

On-Prem Users

Self-hosted installations require additional infrastructure and configuration apart from the above Cloud Control Plane configuration.

PostgreSQL

The AI service uses PostgreSQL for conversation persistence. It shares the control plane's PostgreSQL instance by default — no additional database setup is required.

Helm Configuration

Configure the following components in your testkube-enterprise Helm values:

testkube-ai-service:
  enabled: true # Default: false
  inference:
    defaults:
      secretRef: "<secret-name>" # K8s secret storing the API key
      secretRefKey: "api-key" # Key within the secret
    agent:
      - model: gpt-5.2
        default: true
    tasks:
      model: gpt-5-mini
    embeddings:
      model: text-embedding-3-small

# Enable AI features in the UI
testkube-cloud-ui:
  ai:
    enabled: true # Default: false
    aiServiceApiUri: "https://ai.<your-domain>"

LLM API Key Setup

Create a Kubernetes secret containing your LLM API key:

kubectl -n <namespace> create secret generic <secret-name> \
  --from-literal=api-key=<your-api-key>

tip

The secret must be in the same namespace as the Testkube control plane.

The `inference:` Configuration Block

The inference: block is the recommended way to configure LLM models for the AI service. It uses role-based keys to describe what each model is used for:

Role	Type	Purpose
`agent`	Array	Reasoning models for AI Agents — user-selectable in the Copilot UI
`tasks`	Object (optional)	Lightweight model for title generation, classification. Falls back to default agent model if omitted
`embeddings`	Object (optional)	Embeddings model for vector search. Omit to disable embeddings entirely

Shared Defaults

The defaults section provides shared values inherited by all models unless overridden at the model level:

Field	Description
`provider`	`openai` (default) for OpenAI and OpenAI-compatible endpoints, or `anthropic` for the Anthropic Messages API
`url`	Base URL for LLM API (e.g., `https://proxy.internal/v1`). Defaults to OpenAI, or to Anthropic for `provider: anthropic`, if omitted
`apiKey`	API key (plain text — prefer `secretRef` for production)
`secretRef`	K8s secret name
`secretRefKey`	Key within the secret
`extraHeaders`	Extra HTTP headers merged into all requests
`queryParams`	Query parameters appended to all request URLs
`apiMode`	`responses` or `chat_completions` for every model, see API Mode
`extraBody`	Fields merged into every request body, e.g. gateway routing options

Model Properties

Each model entry (agent, tasks, embeddings) supports these fields in addition to inheriting from defaults:

Field	Description
`model`	Model identifier sent in the API request body (e.g., `gpt-5.2`)
`url`	Custom endpoint URL (overrides `defaults.url`)
`apiKey`	API key for this model (overrides `defaults.apiKey`)
`secretRef`	K8s secret name (overrides `defaults.secretRef`)
`secretRefKey`	Key within the secret (overrides `defaults.secretRefKey`)
`extraHeaders`	Extra HTTP headers (replaces `defaults.extraHeaders` if set)
`queryParams`	Query parameters (replaces `defaults.queryParams` if set)
`provider`	`openai` or `anthropic` (overrides `defaults.provider`) — agent and tasks only
`extraBody`	Request body fields (replaces `defaults.extraBody` if set) — agent and tasks only
`temperature`	Temperature setting — agent and tasks only
`label`	Human-readable name for the UI dropdown — agent only
`default`	Mark which agent model is the default — agent only
`defaultReasoningEffort`	Thinking level used unless the user picks one — agent and tasks only. See Thinking Levels
`reasoningEfforts`	Thinking levels users may pick in the dashboard, in dropdown order — agent only
`apiMode`	`responses` or `chat_completions`; overrides `defaults.apiMode` — agent and tasks only

Override Semantics

Per-model extraHeaders, queryParams and extraBody replace the defaults entirely (not merged key-by-key). If you need both default and model-specific headers, repeat the shared ones in the per-model block.

LLM Provider Examples

For Kubernetes deployment examples and verification commands, see Alternative Model Providers.

OpenAI (Direct)

inference:
  defaults:
    secretRef: "openai-secret"
    secretRefKey: "api-key"
  agent:
    - model: gpt-5.2
      default: true
  tasks:
    model: gpt-5-mini
  embeddings:
    model: text-embedding-3-small

Azure OpenAI — Separate Deployments

Azure OpenAI uses per-deployment URLs, header-based auth, and requires an api-version query parameter:

inference:
  defaults:
    extraHeaders:
      api-key: "azure-shared-key"
    queryParams:
      api-version: "2024-02-01"
  agent:
    - model: gpt-5.2
      default: true
      url: "https://myresource.openai.azure.com/openai/deployments/gpt-5.2"
  tasks:
    model: gpt-5-mini
    url: "https://myresource.openai.azure.com/openai/deployments/gpt-5-mini"
  embeddings:
    model: text-embedding-3-small
    url: "https://myresource.openai.azure.com/openai/deployments/text-embedding-3-small"

vLLM / Local Deployment — No Embeddings

When your LLM provider doesn't support the /v1/embeddings endpoint, omit the embeddings block to disable it:

inference:
  defaults:
    url: "http://vllm.internal:8000/v1"
  agent:
    - model: meta-llama/Llama-3.1-70B
      default: true
      temperature: 0
  tasks:
    model: meta-llama/Llama-3.1-8B
  # embeddings: omitted — embeddings features disabled

LiteLLM Proxy — Multiple Models

inference:
  defaults:
    url: "https://litellm.corp.internal/v1"
    secretRef: "proxy-auth"
    secretRefKey: "api-key"
  agent:
    - model: openai/gpt-5.2
      default: true
    - model: claude-sonnet-5
  tasks:
    model: openai/gpt-5-mini
  embeddings:
    model: openai/text-embedding-3-small

The model names above must match the proxy's configured model_name aliases; provider prefixes are not automatically exposed.

Mixed Providers — Different Keys and Endpoints Per Role

Here Claude uses LiteLLM to translate the OpenAI-compatible requests to Anthropic's API; setting Anthropic headers on its native endpoint does not perform that translation. To call Claude through Anthropic's own API instead, set provider: anthropic (see Anthropic Claude Models).

inference:
  agent:
    - model: claude-sonnet-5
      default: true
      url: "https://litellm.corp.internal/v1"
      secretRef: "proxy-auth"
      secretRefKey: "api-key"
    - model: gpt-5.2
      url: "https://api.openai.com/v1"
      apiKey: "sk-proj-..."
  tasks:
    model: gpt-5-mini
    url: "https://api.openai.com/v1"
    apiKey: "sk-proj-..."
  embeddings:
    model: text-embedding-3-small
    url: "https://api.openai.com/v1"
    apiKey: "sk-proj-..."

K8s Secrets for API Keys

inference:
  defaults:
    url: "https://api.openai.com/v1"
    secretRef: "ai-service-llm-keys"
    secretRefKey: "openai-api-key"
  agent:
    - model: gpt-5.2
      default: true
  tasks:
    model: gpt-5-mini
  embeddings:
    model: text-embedding-3-small
    secretRef: "ai-service-embeddings-key"
    secretRefKey: "api-key"

Testkube Hosted LLM Proxy (Trials Only)

testkube-ai-service:
  enabled: true
  inference:
    defaults:
      url: "https://llm.testkube.io"
    agent:
      - model: gpt-5.2
        default: true
    tasks:
      model: gpt-5-mini

The hosted proxy serves a fixed set of models chosen by Testkube — you cannot add to it:

Chat: gpt-5.2 and gpt-5-mini
Embeddings: text-embedding-ada-002

Any other model name returns an invalid-model error from the proxy. This includes gpt-4o and gpt-4o-mini, which the hosted proxy no longer serves — move any configuration still naming them to gpt-5.2 / gpt-5-mini.

warning

The hosted proxy requires an active trial license, and this is enforced. When a license converts to a commercial plan or passes its expiry date, the proxy stops serving it and the AI service falls back to whatever model credentials you have configured. Set up your own provider before a trial ends, otherwise AI features stop working.

License changes take up to an hour to take effect, in both directions, so access can briefly outlast a converted license or lag behind a renewal.

The proxy also has usage limits and is not recommended for production workloads.

Thinking Levels

Reasoning models accept a thinking level (OpenAI's reasoning_effort): none, minimal, low, medium, high, xhigh or max. Check which values your model accepts.

defaultReasoningEffort sets the level the AI service uses when the user does not pick one.
reasoningEfforts lists the levels users may pick. The dashboard shows a thinking level dropdown next to the model dropdown, in AI Chats and in AI Test Authoring, only for models that list one. The order in the list is the order in the dropdown. If defaultReasoningEffort is not in the list, the first listed level becomes the default.
Omit reasoningEfforts to keep the level fixed at defaultReasoningEffort.

testkube-ai-service:
  inference:
    agent:
      - model: gpt-5.2
        default: true
      - model: gpt-5.6-sol
        label: "GPT-5.6 Sol"
        defaultReasoningEffort: medium
        reasoningEfforts: [low, medium, high]
      - model: gpt-6-astra
        label: "GPT-6 Astra"
        defaultReasoningEffort: high

API Mode

apiMode selects the endpoint the AI service calls for a model: chat_completions (/v1/chat/completions) or responses (/v1/responses). Set it under defaults for every model and override it per model.

The AI service picks the endpoint in this order:

The model's own apiMode, when set. This is the only way to force Chat Completions on a model that needs the Responses API.
responses for models that cannot work on Chat Completions (listed below), even when defaults.apiMode is chat_completions.
defaults.apiMode, when set.
chat_completions, today's default.

Models that switch to the Responses API automatically:

Any model with a thinking level configured (defaultReasoningEffort or reasoningEfforts). Since GPT-5.4, OpenAI only accepts tool calls with a reasoning effort on /v1/responses.
OpenAI gpt-5.6-* models (Sol, Luna, Terra) and gpt-6-* models (Astra).

Models that require `apiMode: responses`

OpenAI serves some models only on /v1/responses. The AI service does not detect these by name, so set apiMode: responses on them explicitly:

Model family	Example identifiers
Codex models	`gpt-5.3-codex`, `gpt-5-codex`, `codex-mini-latest`
Pro reasoning models	`gpt-5.2-pro`, `gpt-5.4-pro`, `gpt-5.5-pro`, `o3-pro`
Any model that returns `only supported in v1/responses`	Check the error returned by your provider

Most proxies and local servers serve /v1/responses today, including LiteLLM, vLLM, Ollama, LM Studio, OpenRouter and Azure OpenAI. If yours does not, keep apiMode: chat_completions for the models behind it.

Examples

Pin today's behaviour for every model (recommended before upgrading). Sol still uses the Responses API because it has thinking levels:

testkube-ai-service:
  inference:
    defaults:
      apiMode: chat_completions
    agent:
      - model: gpt-5.2
        default: true
      - model: gpt-5.6-sol
        defaultReasoningEffort: medium
        reasoningEfforts: [low, medium, high]

Opt in to the Responses API for all models, except one served by a proxy without /v1/responses:

testkube-ai-service:
  inference:
    defaults:
      apiMode: responses
    agent:
      - model: gpt-5.2
        default: true
      - model: gpt-6-astra
        defaultReasoningEffort: high
      - model: my-proxy/llama-3.3-70b
        url: https://proxy.internal/v1
        apiMode: chat_completions

Add a Responses-only model while keeping the Chat Completions default:

testkube-ai-service:
  inference:
    agent:
      - model: gpt-5.2
        default: true
      - model: gpt-5.3-codex
        label: "GPT-5.3 Codex"
        apiMode: responses

Default change ahead

OpenAI recommends the Responses API for all new projects, and the unset default will become responses in a later Testkube release. The AI service logs a warning at startup while defaults.apiMode is unset. Set defaults.apiMode: chat_completions to keep today's behaviour, or responses to opt in now. Models that need the Responses API keep using it either way.

Anthropic Claude Models

The AI service can call Claude models through the native Anthropic Messages API, either directly at api.anthropic.com or through a gateway that serves the Messages API, such as OpenRouter or LiteLLM. Set provider: anthropic on the model, or in defaults for every model:

Inheritance: a model's provider falls back to defaults.provider, then to openai.
url: omit it to call Anthropic directly. For a gateway, use its Anthropic API base, without /v1/messages (for example https://openrouter.ai/api).
Model names: use the identifier your endpoint expects, for example claude-sonnet-5-5 on Anthropic or anthropic/claude-sonnet-5.5 on OpenRouter.
Reasoning effort: defaultReasoningEffort and reasoningEfforts accept low, medium, high, xhigh and max for Claude models, sent as Claude's output_config.effort. Other values are ignored with a warning.
temperature: leave it unset for Claude models.
apiMode: applies to the openai provider only and is ignored for anthropic models.

Moderation and embeddings

Anthropic has no moderation or embeddings API, so provider does not apply to them. The embeddings model always uses an OpenAI-compatible endpoint: keep an OpenAI-compatible embeddings model, or omit the block to disable embeddings. Input moderation, when enabled, calls OpenAI's moderation endpoint and still needs an OpenAI API key, whatever provider the chat models use.

Anthropic Claude (Direct)

Create the secret with your Anthropic API key, then reference it from defaults:

inference:
  defaults:
    provider: anthropic
    secretRef: "anthropic-secret"
    secretRefKey: "api-key"
  agent:
    - model: claude-sonnet-5-5
      label: "Claude Sonnet 5.5"
      default: true
      defaultReasoningEffort: medium
      reasoningEfforts: [low, medium, high]
    - model: claude-opus-5-5
      label: "Claude Opus 5.5"
  tasks:
    model: claude-haiku-4-5
  # embeddings: omitted — Anthropic has no embeddings API

Claude Through a Gateway (OpenRouter)

Some gateways route a Claude request to one of several hosting providers unless the request body names one. Use extraBody to add those fields to every request. With OpenRouter, this pins requests to Anthropic itself:

inference:
  defaults:
    provider: anthropic
    url: "https://openrouter.ai/api"
    secretRef: "openrouter-secret"
    secretRefKey: "api-key"
    extraBody:
      provider:
        order: [anthropic]
        allow_fallbacks: false
  agent:
    - model: anthropic/claude-sonnet-5.5
      default: true
  tasks:
    model: anthropic/claude-haiku-4.5

Direct Anthropic and LiteLLM setups do not need extraBody.

Mixed OpenAI and Anthropic Catalog

defaults.provider sets the provider for every model that does not set its own, so a catalog can offer OpenAI and Claude models side by side, each with its own key:

inference:
  defaults:
    provider: openai
    secretRef: "openai-secret"
    secretRefKey: "api-key"
  agent:
    - model: gpt-5.2
      default: true
    - model: claude-sonnet-5-5
      label: "Claude Sonnet 5.5"
      provider: anthropic
      secretRef: "anthropic-secret"
      secretRefKey: "api-key"
  tasks:
    model: gpt-5-mini
  embeddings:
    model: text-embedding-3-small

Users can switch between the OpenAI and Claude models in the same chat.

Disabling Embeddings

To disable embeddings (e.g., when your LLM provider doesn't support /v1/embeddings), simply omit the embeddings block from your inference: configuration. The AI service will skip vector store initialization and work without embedding-enhanced context.

Authentication Configuration

The AI service requires OAuth/OIDC authentication. Configure one of the following:

Option	Environment Variable	Description
OIDC Discovery (recommended)	`OIDC_CONFIGURATION_URL`	Auto-discovers endpoints from Dex
Manual configuration	`OAUTH_JWKS_URL` + `OAUTH_ISSUER`	Provide both URLs manually

When using Dex (default), authentication is automatically configured via the global Dex issuer settings.

AI Governance

AI governance gives Organization admins control over how AI is used: who can use each AI Agent and model, token limits and pauses, token usage, AI tracing, and MCP events in the Audit log. It's part of every self-hosted control plane with the AI service, so there's nothing to turn on. What each part needs:

Feature	Needs
AI Agent access and model access	PostgreSQL and RBAC in your license
Token limits, pauses and token usage	PostgreSQL
AI tracing	PostgreSQL
Keys stored on AI Agents	PostgreSQL

Without RBAC, everyone who can chat can use every AI Agent and every model. Access settings saved before stay stored and apply again once RBAC is back.

MCP Encryption Key

The control plane encrypts what AI Agents use to sign in to MCP Servers: the keys stored on AI Agents, MCP Server headers and OAuth client secrets, people's MCP sign-ins, and the OAuth state of a sign-in in progress. Set a key so these are stored encrypted. Without one they're stored as they are, and the control plane logs a warning at startup. A key that isn't valid base64 or isn't 32 bytes is ignored the same way.

The key is a base64-encoded 32-byte value. Create it in a Kubernetes Secret under the key encryption-key:

kubectl create secret generic testkube-mcp-encryption \
  --namespace <testkube-namespace> \
  --from-literal=encryption-key="$(openssl rand -base64 32)"

Create the Secret in the namespace you install Testkube into. If it's missing, the pods that read it don't start.

The control plane API, the worker service and the Git provider onboarding worker all read it, and they must use the same key. Set it for all three:

values.yaml
testkube-cloud-api:
  ai:
    encryptionSecretRef: testkube-mcp-encryption

testkube-worker-service:
  ai:
    encryptionSecretRef: testkube-mcp-encryption

testkube-git-provider-onboarding-worker:
  ai:
    encryptionSecretRef: testkube-mcp-encryption

The worker service runs AI Triggers. If its key is missing or different, it can't read an AI Agent's stored keys, and triggers that use those AI Agents fail to sign in to their MCP Servers. The Git provider onboarding worker runs GitHub PR analysis, and the same applies to it.

For local testing you can set ai.encryptionKey to the value itself instead of a Secret. Use encryptionSecretRef in production.

The key is read when a service starts, so restart the control plane API, the worker service and the Git provider onboarding worker after you set or change it. Adding a key to an install that ran without one is safe: values stored before keep working, and they're encrypted the next time they're saved.

Changing the key makes what was stored with the old key unreadable: AI Agent keys, MCP Server headers and OAuth client secrets have to be entered again, and people have to sign in to their MCP Servers again.

Network Requirements

Ensure your firewall allows traffic to:

LLM endpoint — OpenAI API or your custom LLM service
Testkube AI Service API — The deployed AI service endpoint
Trace destinations — When an organization uses AI tracing, the AI service sends traces to AWS X-Ray (xray.<region>.amazonaws.com, or .amazonaws.com.cn in China regions) or the organization's OTLP endpoint

For corporate proxies, inject proxy variables into the AI service pod:

testkube-ai-service:
  enabled: true
  inference:
    defaults:
      secretRef: "<secret-name>"
  extraEnvVars:
    - name: HTTP_PROXY
      value: "http://proxy.domain:8080"
    - name: HTTPS_PROXY
      value: "https://proxy.domain:8043"
    - name: NO_PROXY
      value: ""

Legacy Configuration (Deprecated)

caution

The llmApi, model, models[], and modelsFile keys are deprecated and will be removed in a future release. Please migrate to the inference: block above. Existing deployments using these keys will continue to work — the system automatically maps them to the new format internally.

Legacy configuration reference (click to expand)

Legacy Simple Configuration

testkube-ai-service:
  enabled: true
  llmApi:
    secretRef: "<secret-name>"

Legacy Models Array

testkube-ai-service:
  enabled: true
  models:
    - name: gpt-5.2
      type: primary
      temperature: 0
    - name: gpt-5-mini
      type: lightweight
  llmApi:
    secretRef: "llm-secrets"

Legacy Model Types

Type	New Equivalent	Purpose
`primary`	`agent`	Main reasoning models
`lightweight`	`tasks`	Quick UI enrichment tasks

Legacy Configuration Priority

modelsFile — External YAML file
models — Array of model configurations
model — Simple single model name

Legacy Environment Variables

Variable	New Equivalent	Description
`LLM_API_KEY`	`INFERENCE_DEFAULT_API_KEY`	API key for LLM service
`LLM_API_URL`	`inference.defaults.url`	Custom LLM endpoint
`MODEL_NAME`	`inference.agent[0].model`	Model name
`AI_MODELS_FILE`	`INFERENCE_CONFIG_FILE`	Path to model config file (different YAML schema — not a direct drop-in replacement)
`LLM_EXTRA_HEADERS`	`inference.defaults.extraHeaders`	Extra HTTP headers

Security & Compliance

Data Privacy

Where your data is processed depends on your LLM configuration:

Configuration	Data Residency
Self-hosted LLM	Data never leaves your infrastructure. Supports air-gapped deployments and full compliance with data residency requirements.
Third-party provider (your API key)	Queries and Testkube context (logs, workflow names, execution details) are sent to the provider's API. Review their data handling policies.
Testkube hosted proxy	For trials/demos only. Do not use for production or sensitive environments.

Disabling Telemetry

To disable diagnostic telemetry collection:

testkube-ai-service:
  enabled: true
  extraEnvVars:
    - name: DO_NOT_TRACK
      value: "true"

See Telemetry Configuration for more details.

Air-Gapped Environments

AI functionality supports fully disconnected deployments when using self-hosted LLM infrastructure. See Repackaging Testkube for air-gapped setup guidance.

Feature Flags Reference

Flag/Setting	Location	Default	Purpose
`testkube-ai-service.enabled`	Helm	`false`	Deploy AI service
`testkube-cloud-ui.ai.enabled`	Helm	`false`	Enable UI AI features
`MCP_ENABLED`	Control Plane env	`false`	Enable MCP integration
`AI_SERVICE_URL`	Control Plane env	`""`	AI service URL — required for AI Agent Triggers, session execution and AI tracing test traces
`aiCopilotEnabled`	User settings (API)	`false`	Per-user AI toggle

Environment Variables Reference

The following environment variables can be configured for the AI service:

Required Variables

Variable	Description
`CONTROL_PLANE_ENDPOINT`	URL endpoint for the Testkube Control Plane
`POSTGRES_URI`	PostgreSQL connection string for LangGraph checkpointing

Control Plane Variables

These are set on the Control Plane (cloud-api), not the AI service:

Variable	Required	Description
`AI_SERVICE_URL`	Yes (for AI features)	Base URL of the AI service (e.g. `http://testkube-enterprise-ai-service:9090`). Required for AI Agent sessions and triggers.
`API_BASE_URL`	Yes (for AI features)	External base URL of the cloud-api used by the AI service for callbacks (e.g. `https://api.example.com`)
`MCP_ENABLED`	No	Set to `true` to enable MCP integration (default: `false`)

Inference Configuration

Variable	Description
`INFERENCE_CONFIG_FILE`	Path to the inference configuration YAML file (set automatically by Helm)
`INFERENCE_DEFAULT_API_KEY`	Default API key for inference (from `inference.defaults.secretRef`)

Authentication

Variable	Required	Description
`OIDC_CONFIGURATION_URL`	Conditional	OIDC discovery URL (recommended)
`OAUTH_JWKS_URL`	Conditional	JWK set document URL (if not using OIDC discovery)
`OAUTH_ISSUER`	Conditional	OAuth issuer URL (if not using OIDC discovery)

Quick Start Checklist

Cloud Users

Enable AI Assistant in Organization Settings → Product Features

On-Prem Users

External Secrets

If using External Secrets Operator:

testkube-ai-service:
  externalSecrets:
    enabled: true
    refreshInterval: 5m
    clusterSecretStoreName: secret-store

Testkube AI Overview — High-level overview of all AI capabilities
AI Assistant — Using the AI Assistant in the Dashboard
AI Agents — Creating and managing AI Agents
AI Agent Triggers — Automating agent execution on workflow events
Configuring AI Models — Adding custom models from the Dashboard
AI Architecture — How Testkube AI components work together

Cloud Control Plane Users​

Enable AI Assistant​

Custom Models​

Default LLM and Model​

On-Prem Users​

Helm Configuration​

LLM API Key Setup​

The inference: Configuration Block​

Shared Defaults​

Model Properties​

LLM Provider Examples​

OpenAI (Direct)​

Azure OpenAI — Separate Deployments​

vLLM / Local Deployment — No Embeddings​

LiteLLM Proxy — Multiple Models​

Mixed Providers — Different Keys and Endpoints Per Role​

K8s Secrets for API Keys​

Testkube Hosted LLM Proxy (Trials Only)​

Thinking Levels​

API Mode​

Models that require apiMode: responses​

Examples​

Anthropic Claude Models​

Anthropic Claude (Direct)​

Claude Through a Gateway (OpenRouter)​

Mixed OpenAI and Anthropic Catalog​

Disabling Embeddings​

Authentication Configuration​

AI Governance​

MCP Encryption Key​

Network Requirements​

Legacy Configuration (Deprecated)​

Legacy Simple Configuration​

Legacy Models Array​

Legacy Model Types​

Legacy Configuration Priority​

Legacy Environment Variables​

Security & Compliance​

Data Privacy​

Disabling Telemetry​

Air-Gapped Environments​

Feature Flags Reference​

Environment Variables Reference​

Required Variables​

Control Plane Variables​

Inference Configuration​

Authentication​

Quick Start Checklist​

Cloud Users​

On-Prem Users​

External Secrets​

Related Documentation​

Cloud Control Plane Users

Enable AI Assistant

Custom Models

Default LLM and Model

On-Prem Users

Helm Configuration

LLM API Key Setup

The `inference:` Configuration Block

Shared Defaults

Model Properties

LLM Provider Examples

OpenAI (Direct)

Azure OpenAI — Separate Deployments

vLLM / Local Deployment — No Embeddings

LiteLLM Proxy — Multiple Models

Mixed Providers — Different Keys and Endpoints Per Role

K8s Secrets for API Keys

Testkube Hosted LLM Proxy (Trials Only)

Thinking Levels

API Mode

Models that require `apiMode: responses`

Examples

Anthropic Claude Models

Anthropic Claude (Direct)

Claude Through a Gateway (OpenRouter)

Mixed OpenAI and Anthropic Catalog

Disabling Embeddings

Authentication Configuration

AI Governance

MCP Encryption Key

Network Requirements

Legacy Configuration (Deprecated)

Legacy Simple Configuration

Legacy Models Array

Legacy Model Types

Legacy Configuration Priority

Legacy Environment Variables

Security & Compliance

Data Privacy

Disabling Telemetry

Air-Gapped Environments

Feature Flags Reference

Environment Variables Reference

Required Variables

Control Plane Variables

Inference Configuration

Authentication

Quick Start Checklist

Cloud Users

On-Prem Users

External Secrets

Related Documentation