Deploy Your First AI Agent

In this quickstart, you’ll deploy an AI agent powered by Claude. You’ll create a dependency chain: a secret stores your API key, a model references the secret, an agent uses the model, and a runner deploys the agent to a GKE cluster that Pragmatiks also manages.

Time estimate: 20 minutes. You’ll need an Anthropic API key and a GCP project.

What you’ll build

Eight resources, wired together. When you apply them, Pragmatiks resolves the dependency graph automatically — secrets first, then the model and the cluster, then the agent and the cluster access, then the runner.

Prerequisites

Python 3.13+
A Pragmatiks account
An Anthropic API key
A GCP project with the Kubernetes Engine API enabled and a service account key

Install the CLI

uvx (recommended)
pipx
pip

uv tool install pragmatiks-cli

pipx install pragmatiks-cli

pip install pragmatiks-cli

Authenticate

pragma auth login

This opens your browser. Sign in, and you’re connected.

Build your agent

Create your secret

Secrets store sensitive values like API keys. Create a file called secret.yaml:

secret.yaml

provider: pragma
resource: secret
name: anthropic-key
config:
  data:
    ANTHROPIC_API_KEY: "sk-ant-your-key-here"

Replace sk-ant-your-key-here with your actual Anthropic API key.

pragma resources apply secret.yaml

Create a model

The model resource configures which LLM to use. It references your secret via a field reference — instead of hardcoding the API key, it pulls it from the secret’s outputs.Create model.yaml:

model.yaml

provider: agno
resource: models/anthropic
name: claude
config:
  id: claude-sonnet-4-5-20250929
  api_key:
    provider: pragma
    resource: secret
    name: anthropic-key
    field: outputs.ANTHROPIC_API_KEY

The api_key field uses a field reference: it points to the ANTHROPIC_API_KEY output of the anthropic-key secret. Pragmatiks resolves this automatically.

pragma resources apply model.yaml

Create an agent

The agent resource defines the AI agent’s behavior. It references the model as a dependency — a link to the entire resource, not just one field.Create agent.yaml:

agent.yaml

provider: agno
resource: agent
name: my-assistant
config:
  model:
    provider: agno
    resource: models/anthropic
    name: claude
  instructions:
    - "You are a helpful AI assistant."
    - "Be concise and accurate in your responses."
  markdown: true

The model field is a dependency: it references the full claude model resource. When the model changes, the agent rebuilds automatically.

pragma resources apply agent.yaml

Deploy it

The runner deploys your agent to a Kubernetes cluster. It needs the agents to deploy, a kubernetes/config for cluster access, and a kubernetes/namespace to deploy into.First, store your GCP service account key as a secret. Create gcp-credentials.yaml:

gcp-credentials.yaml

provider: pragma
resource: secret
name: gcp-credentials
config:
  data:
    credentials_json: '{"type": "service_account", "project_id": "your-gcp-project-id", ...}'

Paste your GCP service account JSON key as the credentials_json value. You can get one from the GCP Console under Keys > Add Key > JSON.

Then describe the cluster, how to reach it, and the namespace to deploy into. Create cluster.yaml:

cluster.yaml

provider: gcp
resource: gke
name: my-cluster
config:
  project_id: your-gcp-project-id
  credentials:
    provider: pragma
    resource: secret
    name: gcp-credentials
    field: outputs.credentials_json
  location: europe-west4
  name: my-cluster
---
provider: kubernetes
resource: config
name: my-cluster
config:
  mode: gke_cluster
  cluster:
    provider: gcp
    resource: gke
    name: my-cluster
---
provider: kubernetes
resource: namespace
name: agents
config:
  config:
    provider: kubernetes
    resource: config
    name: my-cluster

The kubernetes/config resource gives Kubernetes resources access to the GKE cluster, and kubernetes/namespace creates the agents namespace in it.

pragma resources apply gcp-credentials.yaml cluster.yaml

GKE cluster creation takes 5-10 minutes. Resources that depend on the cluster wait until it is READY.

Then deploy the agent. Create runner.yaml:

runner.yaml

provider: agno
resource: runner
name: my-assistant
config:
  agents:
    - provider: agno
      resource: agent
      name: my-assistant
  config:
    provider: kubernetes
    resource: config
    name: my-cluster
  namespace:
    provider: kubernetes
    resource: namespace
    name: agents

pragma resources apply runner.yaml

See it work

Check the status of all your resources:

pragma resources list

You should see all eight resources in READY state:

PROVIDER     RESOURCE            NAME              STATUS
pragma       secret              anthropic-key     READY
agno         models/anthropic    claude            READY
agno         agent               my-assistant      READY
pragma       secret              gcp-credentials   READY
gcp          gke                 my-cluster        READY
kubernetes   config              my-cluster        READY
kubernetes   namespace           agents            READY
agno         runner              my-assistant      READY

Get details about your deployed agent:

pragma resources describe agno/runner my-assistant

This shows the runner’s outputs including the service URL where your agent is running.

What just happened?

You created a dependency chain of resources:

Secret stores your API key securely
Model references the secret via a field reference (field: outputs.ANTHROPIC_API_KEY)
Agent depends on the model (whole-resource dependency)
Cluster: gcp/gke reads its credentials from a second secret; kubernetes/config gives access to it and kubernetes/namespace creates the agents namespace
Runner depends on the agent, the Kubernetes config, and the namespace

Pragmatiks resolved the entire chain automatically. It figured out the correct order, waited for each resource to become READY before processing its dependents, and wired the values through. If you update the secret with a new API key, Pragmatiks propagates the change: the model rebuilds with the new key, the agent rebuilds with the updated model, and the runner redeploys.

Full YAML

Here’s everything in a single multi-document file you can copy-paste. Create agent-stack.yaml:

agent-stack.yaml

provider: pragma
resource: secret
name: anthropic-key
config:
  data:
    ANTHROPIC_API_KEY: "sk-ant-your-key-here"
---
provider: agno
resource: models/anthropic
name: claude
config:
  id: claude-sonnet-4-5-20250929
  api_key:
    provider: pragma
    resource: secret
    name: anthropic-key
    field: outputs.ANTHROPIC_API_KEY
---
provider: agno
resource: agent
name: my-assistant
config:
  model:
    provider: agno
    resource: models/anthropic
    name: claude
  instructions:
    - "You are a helpful AI assistant."
    - "Be concise and accurate in your responses."
  markdown: true
---
provider: pragma
resource: secret
name: gcp-credentials
config:
  data:
    credentials_json: '{"type": "service_account", "project_id": "your-gcp-project-id", ...}'
---
provider: gcp
resource: gke
name: my-cluster
config:
  project_id: your-gcp-project-id
  credentials:
    provider: pragma
    resource: secret
    name: gcp-credentials
    field: outputs.credentials_json
  location: europe-west4
  name: my-cluster
---
provider: kubernetes
resource: config
name: my-cluster
config:
  mode: gke_cluster
  cluster:
    provider: gcp
    resource: gke
    name: my-cluster
---
provider: kubernetes
resource: namespace
name: agents
config:
  config:
    provider: kubernetes
    resource: config
    name: my-cluster
---
provider: agno
resource: runner
name: my-assistant
config:
  agents:
    - provider: agno
      resource: agent
      name: my-assistant
  config:
    provider: kubernetes
    resource: config
    name: my-cluster
  namespace:
    provider: kubernetes
    resource: namespace
    name: agents

Apply everything at once:

pragma resources apply agent-stack.yaml

Pragmatiks resolves the dependency order automatically — you don’t need to apply resources in sequence.

Getting started

Concepts

Guides

Troubleshooting

Deploy Your First AI Agent

What you’ll build

Prerequisites

Install the CLI

Authenticate

Build your agent

What just happened?

Full YAML

Next steps

Build a Reactive AI Pipeline

Reactive Dependencies

​What you’ll build

​Prerequisites

​Install the CLI

​Authenticate

​Build your agent

​What just happened?

​Full YAML

​Next steps

Build a Reactive AI Pipeline

Reactive Dependencies

What you’ll build

Prerequisites

Install the CLI

Authenticate

Build your agent

What just happened?

Full YAML

Next steps