# Getting started

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

## 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.

```mermaid
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

- 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

CRDs install first, as their own release:

```bash
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:

```bash
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'
```

:::note[Single-node clusters]
The operator mounts a shared workspace-content volume that the chart requests
as ReadWriteMany. The default provisioners of kind, minikube, k3d and Docker
Desktop offer only ReadWriteOnce, and the operator stays `Pending` waiting for
the volume. On a single-node cluster, add this flag to the install command:

```bash
  --set 'workspaceContent.persistence.accessModes[0]=ReadWriteOnce'
```
:::

Verify that the pods are running:

```bash
kubectl get pods -n omnia-system
```

The operator and dashboard pods reach `Running`.

## Step 2: create a PromptPack

A PromptPack holds the prompts your agent uses, in the [PromptPack format](https://promptpack.org/docs/spec/schema-reference). We store the compiled pack in a ConfigMap under the key `pack.json`:

```yaml
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:

```yaml
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:

```bash
kubectl apply -f configmap.yaml
kubectl apply -f promptpack.yaml
```

Verify the PromptPack:

```bash
kubectl get promptpack assistant-pack
```

The `PHASE` column shows `Active`.

## 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`.

```yaml
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:

```bash
kubectl apply -f provider.yaml
```

Verify the Provider:

```bash
kubectl get provider my-provider
```

The `PHASE` column shows `Ready`.

## Step 4: deploy the agent

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

```yaml
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:

```bash
kubectl apply -f agentruntime.yaml
```

## Step 5: verify the deployment

Check that the agent is running:

```bash
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:

```bash
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 Running](screenshot:agents-list)

## 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:

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

It prints `ServiceGroupNotFound`. To record history, [add a service group](/how-to/workspaces/configure-service-groups/) to the Workspace. The operator rolls the agent's pods when the group's session-api appears, and the condition turns `True`.

## Next steps

- Add tools to the agent in [Adding tools](/tutorials/adding-tools/)
- Connect your own client over WebSocket: [configure agent authentication](/how-to/security/configure-authentication/) and the [WebSocket protocol](/reference/platform/websocket-protocol/)
- Read about [session management](/explanation/agents/sessions/)
- Set up [observability](/how-to/observability/setup-observability/)
- Configure [autoscaling](/how-to/agents/scale-agents/)
- See every [Provider field](/reference/core/provider/)