Skip to content

Architecture

This page explains how Runink TIDE is built: what runs on the cluster, and how trust, data and traffic move through it.

What TIDE is, and what it is not

TIDE is the shared platform for the Runink applications (FACE, PULSE and LUNA), and FORGE is one of its own console categories. Platform concerns live here: self-healing, the event mesh, secrets, the object store, inference serving, MCP, PKI and mTLS, telemetry, the Kubernetes operators and the infrastructure as code.

The apps do not import TIDE. Code that more than one app runs lives in a shared library that TIDE and the apps both import.

Components

ComponentRole
tidethe CLI, the single control surface: dev stack, deploys, images, security scans, sessions, the install wizard. See the CLI reference.
TIDE consolethe web console, served by the TIDE operator.
Operatorsone Kubernetes operator each for FACE, PULSE and TIDE’s generic ClientInstance.
devgatewaythe edge: a DaemonSet on host ports 80 and 443 that terminates TLS with a leaf from TIDE’s own CA and routes each host to its frontend.
ambassadora small static mTLS TCP proxy. Its image is FROM scratch.
modelrouterthe one admission queue in front of the inference engines.
forgecheckthe verifier central CI runs on FORGE projects.
tide-runnerthe self-hosted data-access runner.

What runs on the cluster

Deployments use k0s with pure kustomize overlays (no Helm). The operators are the authoritative source of each pod’s spec and environment.

ClientInstance

ClientInstance (core.runink.org/v1alpha1) is the generic tenant instance the platform places on a shared cluster:

FieldMeaning
appthe application identity. Drives the core.runink.org/app label and the dedicated-taint toleration.
tenantthe tenant key. The core.runink.org/tenant label plus soft node affinity.
rolecontrolplane or runner (default runner): selects the PriorityClass.
imagethe container image to run.
portthe container and service port (default 8080).
replicasdefault 1; ignored when suspend is true.
computeUnitsa sizing budget, mapped to real CPU and memory limits. It is not the billed Compute Unit (one model-slot second); see Plans and billing.
tagsclient labels added to the pod template and ServiceAccount.
placementnodeSelector, tolerations (added to the defaults), affinity (replaces the default soft affinity).
envextra environment variables.
usersaccess grants: email, role (admin, writer or reader, default reader), optional phone, optional expiresAt.
subscriptiontier (lite, dedicated or enterprise), seats, status (active, suspended or past_due).
suspendscale the instance down.

Every operator gives each pod the same isolation labels and scheduling: core.runink.org/{app,tenant,role}, runink.org/{app,tenant,role}, the toleration core.runink.org/dedicated=<app>, soft (anti-)affinity and a priorityClassName. Each namespace carries a ResourceQuota, LimitRange, PriorityClass, NetworkPolicy and PodDisruptionBudget.

Trust: defence in depth

Everything internal is authenticated and encrypted.

  • PKI. Every workload holds a short-lived ECDSA leaf signed by the shared cluster CA, and internal connections use mutual TLS. tide mesh ca mints and distributes that CA.
  • Encryption at rest. Envelope encryption (AES-GCM) is applied by the object store and the connection store, always. Anything that opens either store needs TIDE_ENVELOPE_KEK and refuses to start without it.
  • The object store. TIDE runs its own S3-compatible objectd, which verifies SigV4. The TIDE operator mints every objectd key as a Secret in the consumer’s namespace.
  • App databases. FACE and PULSE seal database values per column before they are written.

Where the console keeps its data

The console keeps its metadata in its own encrypted root:

  • on objectd, when OBJECTSTORE_ENDPOINT and both credentials are set. If objectd is configured but cannot be opened, the console fails closed instead of falling back;
  • otherwise in a local encrypted directory, CONSOLE_APPFS_DIR (default /var/lib/tide/appfs), on its persistent volume.

Each store (agent health, schedules, runs, lineage, governance findings, judgements, rules reconciliation, session commands and runs, GitHub config, cloud providers, connections, subscriptions) is a table in that root. The audit chain is a hash chain that continues across restarts, and GET /api/audit/verify walks it.

The console republishes the few settings the agents read after every change, so change them in the console: an edit made anywhere else is replaced on the next write.

Traffic: the edge and the apps

Each app’s web UI is served by its own small frontend, which serves the Flutter bundle and reverse-proxies gRPC-web, /auth/* and /api/* to the backend. The devgateway edge routes / on each host to that frontend, except gRPC-web calls, which it sends straight to the app backend. Native gRPC (the mobile and desktop apps) also goes to the frontend, and is carried there over cleartext HTTP/2 (h2c) so its trailers survive.

The devgateway has its own sign-in gate. When edge auth is on, an empty DEVGW_AUTH_ALLOWED_EMAILS refuses every sign-in. Admitting any verified Google account needs the explicit DEVGW_AUTH_ALLOW_ANY_VERIFIED=true. Edge sessions are kept server-side.

FORGE runs inside the TIDE console (FORGE › Studio is a console route), on TIDE’s session.

Inference

The model plane is sovereign: no hosted model is called. mistral.rs is the engine of every language tier. The model router is the one admission queue in front of the engines, and every app and agent calls it by tier. Each tier’s backend is one router setting (BACKEND_<TIER>):

  • general and coder (one Qwen3.8-27B), guard, reranker and stt are served by one inference server outside the cluster, reached through servefwd, which forwards one port per tier and keeps the server’s bearer out of every pod;
  • embedding, vision and imagegen are served on the cluster itself.

Servers are attached dynamically: the off-cluster servers are declared in the tide-servers ConfigMap and appear on DevEx › Clusters › Nodes & servers. Agent budgets derive from a configured decode rate, INFERENCE_DECODE_TOK_S. See Models & inference.

Delivery

There is no Argo CD. Delivery is GitHub Actions: tide-cd.yml builds the images a merge changed, applies the kustomize overlays, rolls the workloads, and records each deploy in the console’s lineage record, which DevEx › Clusters › GitOps and Audit Chain › Deploy lineage read.

Networking

Manifests work on IPv6 single-stack, IPv4 single-stack and dual-stack clusters: services bind [::], and no Service is pinned to one address family.

Images

tide build builds local podman images only. The images the cluster runs are built in the cluster (werf and buildah in an ephemeral Job) and pushed to the node-local registry. Every Dockerfile pins its base image by @sha256: digest, and the base images are mirrored with tide images mirror.

After a delivery roll, workloads run a digest-pinned :latest@sha256:…. A bare kubectl rollout restart then restarts onto the same digest. To move a workload onto new images, run the delivery workflow for that image.