Deploy Your First AI Agent

In this quickstart, you’ll deploy an AI agent powered by Claude. You’ll create four resources that form 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 Kubernetes.

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

What you’ll build

Four resources, wired together. When you apply them, Pragmatiks resolves the dependency chain automatically — the secret provisions first, then the model, then the agent, 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 two dependencies: the agent to deploy and a GKE cluster to deploy it on.First, create the cluster. Create cluster.yaml:

cluster.yaml

provider: gcp
resource: gke
name: my-cluster
config:
  project_id: your-gcp-project-id
  credentials:
    type: service_account
    project_id: your-gcp-project-id
    private_key_id: "..."
    private_key: "-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----\n"
    client_email: "sa@your-gcp-project-id.iam.gserviceaccount.com"
    client_id: "..."
    auth_uri: "https://accounts.google.com/o/oauth2/auth"
    token_uri: "https://oauth2.googleapis.com/token"
  location: europe-west4
  name: my-cluster

Paste your GCP service account JSON key into the credentials field. You can get one from the GCP Console under Keys > Add Key > JSON.

pragma resources apply cluster.yaml

GKE cluster creation takes 5-10 minutes. Wait for it to reach READY state before continuing.

Then deploy the agent. Create runner.yaml:

runner.yaml

provider: agno
resource: runner
name: my-assistant
config:
  agent:
    provider: agno
    resource: agent
    name: my-assistant
  cluster:
    provider: gcp
    resource: gke
    name: my-cluster

pragma resources apply runner.yaml

See it work

Check the status of all your resources:

pragma resources list

You should see all five resources in READY state:

PROVIDER   RESOURCE            NAME            STATUS
pragma     secret              anthropic-key   READY
agno       models/anthropic    claude          READY
agno       agent               my-assistant    READY
gcp        gke                 my-cluster      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)
Runner depends on both the agent and the GKE cluster

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: gcp
resource: gke
name: my-cluster
config:
  project_id: your-gcp-project-id
  credentials:
    type: service_account
    project_id: your-gcp-project-id
    private_key_id: "your-key-id"
    private_key: "-----BEGIN PRIVATE KEY-----\nyour-private-key\n-----END PRIVATE KEY-----\n"
    client_email: "sa@your-gcp-project-id.iam.gserviceaccount.com"
    client_id: "your-client-id"
    auth_uri: "https://accounts.google.com/o/oauth2/auth"
    token_uri: "https://oauth2.googleapis.com/token"
  location: europe-west4
  name: my-cluster
---
provider: agno
resource: runner
name: my-assistant
config:
  agent:
    provider: agno
    resource: agent
    name: my-assistant
  cluster:
    provider: gcp
    resource: gke
    name: my-cluster

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