aalgo.

Kubernetes platforms.
LLM systems.
In production.

aalgo designs, builds and runs the platform under your product and the language models inside it: clusters described entirely in git, models served on your own GPUs or through APIs, and the pipelines that ship both, safely, every day.

LLMs on Kubernetes See the work
KubernetesHelmArgo CDIstio OpenTofuGitHub ActionsGPU nodesvLLM OllamaClaude · OpenAI APIsRabbitMQGrafana · Loki

Kubernetes platform engineering

A platform your team can trust: reproducible from git, secure by default, and boring to operate.

Clusters & GitOps

Every workload, setting and version lives in git and is reconciled by Argo CD.

  • Cluster design and provisioning with OpenTofu
  • Helm charts, versioned and published as OCI packages
  • Manual-sync GitOps with reviewed, pinned releases
  • Separated projects and namespaces for apps, staff tools and platform

Secure & scalable

Workloads that scale to N replicas and pass security gates before they reach the cluster.

  • Stateless services, no sticky sessions, rolling releases
  • Istio ingress gateway, TLS everywhere
  • Checkov, Kubescape, kubeconform and image scans in CI
  • Least-privilege pipelines: CI never holds cluster credentials

Operate & observe

See what the platform does, and know before your users do.

  • Grafana, Loki and Alloy for logs and metrics
  • Structured logs with trace ids, no secrets in logs
  • Durable queues, retries and dead-letter handling
  • Runbooks and alerts that someone can actually follow

LLM engineering

Language models doing real work in real products, with quality, cost and safety under control.

Self-hosted models

Open models on your own infrastructure, when data must stay in-house or volume makes APIs expensive.

  • Inference servers such as vLLM and Ollama
  • Model selection, quantization and sizing for your GPUs
  • OpenAI-compatible endpoints your apps already speak

API-based models

Claude, OpenAI and others, integrated behind your own interfaces so you can switch.

  • Translation, classification and moderation pipelines
  • Prompt and output contracts, validation, fallbacks
  • Budgets, caching and rate limits so the bill stays predictable

Agents & evaluation

From prototype to something you can measure and trust.

  • Evaluation sets and regression checks before each change
  • Guardrails and human review where it matters
  • AI coding agents in the delivery workflow, reviewing each other

LLMs on Kubernetes

Where the two meet: models run as first-class, observable, scalable services of your platform.

GPU-aware cluster

GPU node pools, scheduling and quotas so inference and the rest of your workloads share the cluster fairly.

Serving as a service

Model servers deployed with Helm and GitOps like any other app: versioned, reviewed, rolled out and rolled back.

Async by design

LLM work behind queues and workers with retries and idempotency, so a slow model never blocks a request.

Measured

Latency, throughput, token cost and errors on the same dashboards as the rest of the platform.

Recent work

A multilingual marketplace, built from scratch and run on Kubernetes, with LLM workers at its core.

  • Kubernetes on DigitalOcean, Istio gateway, Helm charts published as OCI packages
  • Argo CD GitOps across separate app, staff and platform projects; infrastructure in OpenTofu
  • RabbitMQ workers calling an LLM to translate content into seven languages and classify listings
  • N-replica services with rolling releases, durable queues and idempotent consumers
  • CI with tests, IaC security scans and image checks; delivery with AI coding agents under review

For companies and startups

Need a platform built, an existing cluster brought under control, or an LLM feature taken from demo to production? aalgo works with in-house teams and early-stage products across Europe.