Skip to content
ALTAIRA LABS
DocsBlog
OmniaOmnia

Getting started

In this tutorial we install Omnia, deploy an agent, and talk to it in the dashboard.

What you will build

Section titled “What you will build”

We create four resources in the default namespace. The operator turns the AgentRuntime into a running agent pod, and the dashboard console talks to that pod.

flowchart LR
  Console["Dashboard console"] --> Agent["AgentRuntime my-assistant"]
  Agent --> Pack["PromptPack assistant-pack"]
  Pack --> CM["ConfigMap assistant-prompts"]
  Agent --> Prov["Provider my-provider"]
  Prov --> Sec["Secret llm-credentials"]

Prerequisites

Section titled “Prerequisites”
  • A Kubernetes cluster, version 1.26 or later, with a StorageClass that provides ReadWriteMany volumes (on a single-node cluster, see the note in step 1)
  • kubectl configured to reach the cluster
  • Helm v3
  • An Anthropic API key

Step 1: install Omnia

Section titled “Step 1: install Omnia”

CRDs install first, as their own release:

Terminal window
helm install omnia-crds oci://ghcr.io/altairalabs/charts/omnia-crds \
  --devel \
  --namespace omnia-system --create-namespace

Now we install the operator and dashboard. The flags set the dashboard’s built-in admin password, create a Workspace named default over the default namespace, and give the admin owner access to it. Built-in users live in a PostgreSQL database and signed-in sessions in Redis, so the dev.* flags run a single-pod Postgres and Redis in the cluster for the tutorial:

Terminal window
helm install omnia oci://ghcr.io/altairalabs/charts/omnia \
  --devel \
  --namespace omnia-system \
  --set dashboard.auth.mode=builtin \
  --set dashboard.builtin.admin.password=tutorial-admin-pw \
  --set dev.enabled=true \
  --set dev.postgres.enabled=true \
  --set dev.redis.enabled=true \
  --set redis.default.host=omnia-redis-master.omnia-system.svc.cluster.local \
  --set managementApi.database.existingSecret=omnia-postgres-management \
  --set defaultWorkspace.enabled=true \
  --set defaultWorkspace.namespace.name=default \
  --set defaultWorkspace.namespace.create=false \
  --set 'defaultWorkspace.directGrants[0].user=admin@example.com' \
  --set 'defaultWorkspace.directGrants[0].role=owner'

Verify that the pods are running:

Terminal window
kubectl get pods -n omnia-system

The operator and dashboard pods reach Running.

Step 2: create a PromptPack

Section titled “Step 2: create a PromptPack”

A PromptPack holds the prompts your agent uses, in the PromptPack format. We store the compiled pack in a ConfigMap under the key pack.json:

apiVersion: v1
kind: ConfigMap
metadata:
  name: assistant-prompts
  namespace: default
data:
  pack.json: |
    {
      "$schema": "https://promptpack.org/schema/latest/promptpack.schema.json",
      "id": "assistant",
      "name": "Assistant",
      "version": "1.0.0",
      "template_engine": {
        "version": "v1",
        "syntax": "{{variable}}"
      },
      "prompts": {
        "main": {
          "id": "main",
          "name": "Main Assistant",
          "version": "1.0.0",
          "system_template": "You are a helpful AI assistant. Be concise and accurate in your responses. Always be polite and professional.",
          "parameters": {
            "temperature": 0.7,
            "max_tokens": 4096
          }
        }
      }
    }

Then we create the PromptPack resource that references the ConfigMap:

apiVersion: omnia.altairalabs.ai/v1alpha1
kind: PromptPack
metadata:
  name: assistant-pack
  namespace: default
spec:
  packName: assistant-pack
  version: "1.0.0"
  source:
    type: configmap
    configMapRef:
      name: assistant-prompts

Save the two manifests as configmap.yaml and promptpack.yaml, and apply them:

Terminal window
kubectl apply -f configmap.yaml
kubectl apply -f promptpack.yaml

Verify the PromptPack:

Terminal window
kubectl get promptpack assistant-pack

The PHASE column shows Active.

Step 3: configure the LLM provider

Section titled “Step 3: configure the LLM provider”

We store the API key in a Secret and create a Provider that uses it. For type claude, the Provider reads the key ANTHROPIC_API_KEY.

apiVersion: v1
kind: Secret
metadata:
  name: llm-credentials
  namespace: default
type: Opaque
stringData:
  ANTHROPIC_API_KEY: "sk-ant-..."
---
apiVersion: omnia.altairalabs.ai/v1alpha1
kind: Provider
metadata:
  name: my-provider
  namespace: default
spec:
  type: claude
  model: claude-sonnet-4-20250514
  credential:
    secretRef:
      name: llm-credentials

Replace the placeholder key, save the file as provider.yaml, and apply it:

Terminal window
kubectl apply -f provider.yaml

Verify the Provider:

Terminal window
kubectl get provider my-provider

The PHASE column shows Ready.

Step 4: deploy the agent

Section titled “Step 4: deploy the agent”

An AgentRuntime ties the PromptPack and the Provider into a running agent. We expose one WebSocket facade:

apiVersion: omnia.altairalabs.ai/v1alpha1
kind: AgentRuntime
metadata:
  name: my-assistant
  namespace: default
spec:
  promptPackRef:
    name: assistant-pack
  providers:
    - name: default
      providerRef:
        name: my-provider
  facades:
    - type: websocket
      port: 8080

Save the file as agentruntime.yaml and apply it:

Terminal window
kubectl apply -f agentruntime.yaml

Step 5: verify the deployment

Section titled “Step 5: verify the deployment”

Check that the agent is running:

Terminal window
kubectl get agentruntime my-assistant
kubectl get pods -l app.kubernetes.io/instance=my-assistant
kubectl get svc my-assistant

The AgentRuntime’s PHASE column shows Running once the agent pod is ready.

We open the dashboard next. Port-forward it:

Terminal window
kubectl port-forward -n omnia-system svc/omnia-dashboard 3000:3000

Browse to http://localhost:3000 and sign in as admin with the password tutorial-admin-pw. Open Agents. The page lists the agent with its status:

The Agents page listing my-assistant in phase RunningThe Agents page listing my-assistant in phase Running

Step 6: chat with the agent

Section titled “Step 6: chat with the agent”

Open my-assistant and select Console. Type Hello, who are you? and press Enter.

The agent streams a reply from Claude into the console. You have deployed your first agent with Omnia.

This conversation is not recorded. Session history is written to a session-api, and the default Workspace we installed has no service group, so it has none. The AgentRuntime says so in its SessionRecording condition:

Terminal window
kubectl get agentruntime my-assistant \
  -o jsonpath='{.status.conditions[?(@.type=="SessionRecording")].reason}'

It prints ServiceGroupNotFound. To record history, add a service group to the Workspace. The operator rolls the agent’s pods when the group’s session-api appears, and the condition turns True.

Next steps

Section titled “Next steps”