QBO API

The QBO API

One API for the whole stack — Kubernetes, containers, workstations, networking, registry, certificates, observability and security. Driven in natural language, running on your own metal.

Schedule a Discovery Meeting
QBO Platform API

What it is

The editor, the pipeline, the cluster and everything under it — in one box.

Think of what you already run to ship software: an AI editor, a source and CI platform, a managed Kubernetes service, a container engine, a load balancer, observability, security, networking, a private registry and certificate automation. QBO is all of that as a single API on your own hardware, with an AI editor on top and our own model, Animas, doing the reasoning.

Nothing is stitched together, because nothing is separate. One API operates every layer, so the same command surface that creates a cluster also issues its certificates, opens its network path and tells you what it is doing.

From an idea to production on your laptop — then the same software in the datacenter, at scale.

What the API operates

Kubernetes

CNCF-conformant clusters in seconds. Lifecycle, scaling, nodes, kubeconfig and GPU enablement, answering your own kubectl and your unmodified manifests.

MC2 containers

Containers straight on the host kernel — no hypervisor, no guest OS, no virtualization tax between the workload and the hardware.

Workstations

GPU and Windows desktops provisioned like any other resource, on the same metal, through the same API.

Chat

The control surface. Describe what you want in plain English and the platform provisions it, inspects it and enforces policy on it.

Metrics and observability

Per-core CPU, memory, per-disk, per-NIC and per-GPU utilization streamed live as it changes, with kernel flow events per packet.

Networking

Encrypted overlay, virtual IPs, DNS records and load balancing, with an eBPF dataplane executing in the kernel rather than a userspace proxy.

Security

Deny-by-default ingress and micro-segmentation held per identity in a BPF map, enforced in the kernel. Its own users, service accounts and fleet-wide SSO — no external directory.

Registry and certificates

A private container registry with images held locally, and ACME certificates issued and rotated by the platform itself.

AI

Animas-R for reasoning and Animas-V for vision, both running inside the enclave. There is no cloud API to call.

Editor and Git

An AI editor with GitHub integration built in — write, review and ship from the same place you operate the infrastructure, backed by GPT, Anthropic or our own Animas models.

Agents and MCP

An MCP server exposed by the platform itself, so agents, editors and assistants drive real infrastructure as tools — with progress streaming back as the work happens.

Everything it does

Kubernetes

  • Multi-cluster management
  • Cluster scaling, start, stop and delete
  • Node add, remove, start and stop
  • Kubeconfig management
  • Kubernetes API integration
  • CNCF conformance
  • CNI networking
  • GPU enablement
  • Kubernetes image support, stock or custom

Compute

  • MC2 containers on the host kernel
  • Container engine
  • GPU workstations
  • Windows workstations
  • Custom images
  • Persistent storage volumes
  • Storage scoped per user
  • amd64 and arm64

Networking

  • Encrypted overlay across every host
  • Virtual IP addresses
  • IP network management
  • Load balancing
  • DNS records
  • eBPF dataplane in the kernel
  • Ingress

Security and identity

  • Its own users and service accounts
  • Fleet-wide single sign-on
  • OAuth2 providers
  • TLS and ACME certificates, issued and rotated
  • Deny-by-default ingress
  • Micro-segmentation per identity
  • Per-instance network namespaces
  • Ownership checked before forwarding
  • RMF and SCAP evidence, no agent

Registry and images

  • Private container registry
  • Images held locally, no reachback
  • External registry integration
  • Custom image support

Observability

  • Per-core CPU and memory
  • Per-disk usage
  • Per-NIC throughput
  • Per-GPU utilization and VRAM
  • Kernel flow events, per packet
  • Bytes and packets per firewall rule
  • Structured logs to the microsecond
  • Live streaming, pushed not polled

AI

  • Animas-R reasoning, in the enclave
  • Animas-V vision, in the enclave
  • Natural-language provisioning
  • Natural-language inspection and policy
  • AI editor with GitHub integration
  • Model backends: OpenAI GPT and Anthropic Claude
  • Or our own Animas models, fully local
  • Bring your own OpenAI-compatible endpoint
  • No cloud API, no keys, no reachback when local

Interfaces

  • Websockets AsyncAPI
  • MCP server, Streamable HTTP
  • MCP tool calling for agents
  • Progress streamed over SSE
  • Agent with OpenAI-compatible backends
  • Command-line interface
  • Web interface
  • Web terminal
  • QBO Desktop for Windows, Linux and macOS
  • Real-time state through mirrors
  • In-memory cache

Why it is built this way

One platform, one binary
Network, registry, DNS, TLS, storage, security and observability ship together — not a stack of products to integrate and keep in step.
Real-time by design
An AsyncAPI over websockets, so cluster, container, process and thread state arrives as it changes rather than being polled for.
Bare metal, cloud flexibility
Pure containers on a single host kernel. Create, delete, start, stop and scale at speeds virtual machines cannot reach.
Native kernel functions
One kernel per host to secure and observe, instrumented through eBPF, IPVS, netfilter and iproute2 rather than sidecars.
Airgap-native
Nothing to reach out to at runtime. Identity, certificates, registry and AI are all local, so denied comms is not denied capability.
Laptop to datacenter
The same software and the same behaviour on a developer machine and on a rack, amd64 and arm64 alike.

From an idea to a deployment at scale — in a sentence.

Technical documentation, API reference and the CLI live on the docs site.

Read the documentation