Skip to content

From commit to production, with policy and evidence

Software Delivery · Runtime, CI/CD and deployment

The Compute runtime deploys containerized applications to the cloud from a config file, keeps every revision and lets you roll back to the previous one. Around it sits the whole cycle: builds and tests on isolated runners or on your own runner, an artifact registry with provenance, canary and blue-green, delivery to your Kubernetes cluster, gated releases, infrastructure and database changes reviewed before they apply, and governance that freezes deployments, requires a second person's approval and asks for the change ticket. Each feature appears below with what it does and where it stops.

Preview
Destinos de deploy

The problem

What this product solves

Small teams lose days setting up where to run a service that should take an afternoon to launch.

When something breaks, the basics are missing: which version is live, who changed it, how to roll back and what it is costing.

And each delivery stage usually lives in a different tool with its own approval rule: the build in one place, the image in another, the infrastructure in a third. Nobody can show the full path of a change.

updated

Who uses it, and for what

Typical profiles, no customer names. Each use carries the status of the feature behind it.

  • Product team at a startupDeploy an internal API or a GPU model without setting up servers, with a spending cap per workspace and revision rollback.Compute runtime
  • Platform teamPromote a release through dev, staging and production, with a window, tests, scans and approval before each environment.Release Orchestration
  • Platform team with change managementFreeze deployments on a critical date and require an approved change ticket before every deployment.Deployment Governance

Features

What the product does

Self-service: add it from your account.

  • Compute runtime

    CPU and GPU application runtime with revisions, rollback, logs and secrets.

  • Pipelines

    Builds and tests on isolated runners (Node, Python and Go) or on your self-hosted runner, with matrix, push, pull request and scheduled triggers, variables and secrets, JUnit reports, coverage and test policy. Time-boxed quarantine for flaky tests, test splitting by duration and selection by what changed; probable failure cause, AI explanation of the failed step, build summary, stage graph, per-step timing and failed and slowest tests on the run. Approvals that pause the run (policy or approval stage), with approvers, a deadline and decisions on screen, through the API and via webhook notices; a dependency cache on the managed runner per workspace, repository and lockfile, through signed URLs. Image builds from a Dockerfile (Kaniko, no Docker socket or privileged mode) pushed by digest to the workspace Artifact Registry, layer cache in the registry and image scanning as a gate. The managed runner serves public and private GitHub repositories, through the AIUBY GitHub App or a token.

  • Progressive Delivery

    Canary and blue-green on Compute via Cloud Run traffic splitting: observed traffic steps, verification by revision health, error rate, latency and incidents, automatic traffic rollback on abort, policy approval before 100% and change windows.

  • Kubernetes & GitOps

    Delivery to the customer Kubernetes cluster from a manifest folder (YAML + kustomization.yaml with images and replicas) in a connected repository: an agent installed in the cluster pulls the desired state over outbound HTTPS and applies only Deployments, Services and ConfigMaps in the environment namespace, with no cluster credential stored by AIUBY. A new commit on the environment branch becomes a diff and a rolling or replica-based canary rollout, with readiness reported by the agent, incidents, manual checks, policy, manifest rules and change windows, drift reporting, an application generator from a list of environments and production rollouts in DORA. Helm is not rendered (commit the helm template output); no traffic-based canary (service mesh/ingress).

  • Release Orchestration

    A release as a set of applications promoted through ordered environments (dev, staging, production), gated before each one: freeze, change window, policy as code, passing E2E suite, scan with no open critical finding, per-resource queue, database migration applied at the commit and approval; a timeline with every gate, rollout and decision; Jira issue tracing; approve and roll back from the app, the API and the CLI (aiuby releases get, approve and rollback). Covers Kubernetes & GitOps applications; Compute is not part of releases.

  • Deployment Governance

    Deployment freezes by period targeting Compute, Kubernetes and pipelines, which no approval overrides; policy before every Compute deployment with an approval request tied to the revision and config hash; requesters cannot approve and API keys never approve; minimum N approvals and approver groups; a Jira or ServiceNow change ticket as a condition; a screen with the workspace queue and freezes; events on webhooks, Slack included.

  • Delivery Controls

    Checks between code and production: a dependency firewall enforced by CI and the npm proxy, artifact provenance, an IaC module registry and plans requested by the pipeline, test quarantine, splitting and selection, per-resource queues and database gates on releases, a per-environment application generator and Jira issue tracing, with every rule and block in the audit trail.

  • Repositories

    GitHub repositories connected to the workspace with a read-only token (private ones included) and linked to the graph, CI and scanners; pipeline status checks published on the commit, which GitHub branch protection can require; full-text code search on the default branch from the app, the API and the aiuby-repo CLI. AIUBY does not host Git.

  • Infrastructure as Code

    Managed plan and apply with OpenTofu in AIUBY's isolated executor: IaC workspaces (repository, directory, variables inherited from the environment, input sets and runner and approver roles), state always in your own S3 or GCS backend with locking, short-lived federated identity in your cloud (AWS and GCP), plans evaluated by IaC Review and the environment policy, apply only from a reviewed plan (by hash) with human approval, a per-workspace queue and scheduled read-only drift detection. Also: list-price cost estimates, blast radius with graph services, dependencies between workspaces, a versioned module registry, plans requested by the pipeline, plans commented on pull requests, time-boxed ephemeral workspaces and drift that becomes a Code Automation task. Does not store state or plans, does not create roles in your cloud, does not import resources and does not run Terraform (OpenTofu only).

  • Database DevOps

    Database registry per environment (no connection address or credentials stored by AIUBY), history of the migrations CI or the runner applied and reported, a gate before applying (required rollback, passing migration check, promotion order and changed content), schema diff across environments from CI snapshots or the data connector with verified TLS, and database events in the audit trail. The customer's self-hosted runner applies Flyway or Liquibase SQL changelogs after another person approves the plan by hash, rolling the batch back if a migration fails; AI-written migrations go through the SQL rules and another person's review. The platform does not dry-run SQL.

  • IaC Review

    Terraform/OpenTofu change review in CI: reads the PR .tf files or, preferably, the plan JSON produced in your CI with your credentials; flags destroys, replacements, hardcoded secrets, 0.0.0.0/0 and public buckets, estimates impact, detects drift against the last recorded apply and decides by environment policy (approval in the app). The platform does not run terraform and stores neither state nor the plan.

  • Database Migration Review

    SQL migration review in CI (Postgres; basic MySQL), without connecting to your database: DROP, TRUNCATE, rewriting type changes, NOT NULL without DEFAULT, non-concurrent indexes, renames, expand and contract in one release and missing rollbacks, decided by environment policy. Does not apply migrations or diff schemas across environments.

  • Self-hosted Runner

    Customer-owned runner (VM or Kubernetes), a pull agent with one key per runner, that runs CI jobs with up to 4 service containers, per-tool dependency and build caches, closed-catalog step plugins and CPU and memory metrics, plus Ansible playbooks and applying approved migrations, with the target credential kept only on its machine. Fork pull requests are blocked before dispatch.

  • Artifact Registry

    Docker and npm repositories per workspace on AIUBY's Google Artifact Registry (São Paulo), with 15-minute push/pull credentials from a service account scoped to the organization, a catalog with digest, tags, size, date and publisher, links to repository and commit in the graph, provenance tied to the run, commit and digest, a dependency firewall with an npm proxy, audited retention policy, published and removed version events, per-repository access logs and a Compute deployment gate that rejects images without a scan or a verified signature when the workspace requires it. Cosign signatures verified against the workspace's ECDSA P-256 public key (no keyless or transparency log). Maven and PyPI are not supported.

CLI

From terminal to live

The path through the public CLI, with a workspace API key. Deploying requires a balance, a monthly Compute cap and the "Deploy to Compute" scope.

  1. npm install -g @aiuby-ia/cli

    Installs the CLI.

  2. aiuby login

    Stores the API key; it does not appear on screen or in your shell history.

  3. aiuby init fastapi-http minha-api

    Copies a starter template with aiuby.toml.

  4. aiuby config validate

    Checks aiuby.toml without using the network.

  5. aiuby apps create

    Registers the application with its first revision; does not deploy.

  6. aiuby deploy --dry-run minha-api

    Shows the plan, without creating anything.

  7. aiuby deploy minha-api

    Deploys the current revision and follows it until it is running.

  8. aiuby logs minha-api

    Latest log lines from the deployment.

  9. aiuby rollback minha-api 3

    Saves a new revision with the configuration of revision 3.

Compute runtime

See every command in the documentation

Preview

What is in validation

It exists in the code and is in internal validation. It is not open to customers; when it opens, the AIUBY team enables it one organization at a time.

  • Preview

    Destinos de deploy

    Delivers the CI-approved artifact (image by digest or commit) outside Compute: AWS ECS in the customer account through a role with an ExternalId, with no stored keys; a Linux server with an agent that pulls orders over outbound HTTPS and rolls back on its own when health fails; and Vercel, from the approved commit, rolling back to the previous deployment. Every delivery is audited.

How it works

From start to audit record

  1. Build and test

    On every push, builds and tests run on an isolated runner, with a matrix, JUnit reports, coverage and a diagnosis of what failed.

  2. Store the artifact

    The image goes to the workspace registry with a 15-minute credential. The catalog shows digest, signature and publisher.

  3. Review infrastructure and database

    The Terraform or OpenTofu plan and SQL migrations go through rules and the environment policy before any apply.

  4. Deploy

    A config file sets image, hardware, variables and replicas. Every deployment, from the web app or the public CLI, creates a new revision.

  5. Roll out gradually

    The new revision gets traffic in steps while health, error rate, latency and incidents are watched. A bad signal sends traffic back to the stable revision.

  6. Promote across environments

    The release moves from dev to production with a window, policy, tests, scans and approval before each environment, on a single timeline.

Features

Feature by feature

What each one does, how it works, an example from the documentation and what it does not do. Each badge comes from the catalog.

Compute runtime

Your containerized application live, with revisions you can roll back

Compute runtime runs containerized applications in the cloud from an aiuby.toml file that sets the image, port, hardware (CPU or GPU) and replicas. Every configuration change becomes a numbered revision, and none is ever deleted.

Before deploying, the plan shows what would be created and what blocks the deployment. Once live, the application gets an address, logs, encrypted secrets and a monthly spending cap in the workspace.

How it works

  • Deploy from the signed-in area, the public CLI (@aiuby-ia/cli) or the API, with keys scoped separately to read, manage and deploy.
  • Revisions do not change once saved: rolling back saves a new revision with the chosen one's configuration, and the rollback is recorded in the audit log.
  • CPU in São Paulo, with up to 3 replicas that scale up as requests arrive and back to zero when the application is idle.
  • GPU with one card per application: NVIDIA L4 (24 GB) or NVIDIA RTX PRO 6000 (96 GB), on the exact machine for each.
  • Secrets saved through the UI, CLI or API, encrypted in the database (AES-256-GCM) and delivered to the application as environment variables; the value never comes back through the UI, API, logs or audit log.
  • Public address, or one protected by a 1-hour access token issued by the platform for that application only.
Through the CLI From template to live application, with logs and a rollback to revision 3's configuration.
aiuby init fastapi-http minha-api   # copies a starter template
cd minha-api
aiuby config validate               # checks aiuby.toml, without using the network
aiuby apps create                   # registers; does not deploy
aiuby deploy --dry-run minha-api    # shows the plan
aiuby deploy minha-api
aiuby logs minha-api
aiuby rollback minha-api 3

What it does not do

  • It only runs container images; it does not build from source code.
  • It has no volumes or custom domains.
  • It does not go beyond 3 replicas on CPU or 1 replica with GPU, and does not keep a minimum replica count above zero.
  • It does not offer GPU in Brazil: the cards are in Europe (Belgium and the Netherlands).

Pipelines

Build and test on every change, with the reason for each failure

Pipelines runs a repository's build and tests in isolated executors, one per job, with Node 22, Python 3.12 and Go 1.26 images, or on the customer's own runner. The definition is versioned JSON with stages, dependencies between them, a matrix, conditions by branch or event, variables and secrets. On the managed executor, the dependency cache (npm, pip and Go) is stored per workspace, repository and lockfile hash and reaches the job through a short-lived signed URL.

Each run returns the result of every step, tests read from JUnit reports and coverage (lcov or Cobertura). When something fails, the run points to the step, the exit code, the end of the log, the tests that broke and the likely cause by rule, and a workspace admin can ask right there for an AI explanation of the failed step; the build can leave its own summary in .aiuby/summary.md, shown as text.

How it works

  • Manual, push (with path filters), pull request or scheduled triggers, with a GitHub webhook whose signature is verified; fork pull requests never receive secrets.
  • Test policy per stage: minimum line coverage and a requirement for JUnit tests fail the job even when all steps are green.
  • Flaky tests are detected when the same test passes and fails on the same commit, with a quarantine of up to 90 days that only forgives failures of those tests; tests split into N parts of similar duration and selection by what changed.
  • Policy as code evaluated before any job exists (ci.run action) and when the pipeline is saved; a freeze targeting pipelines refuses push, scheduled and manual triggers.
  • Approvals that pause: when the policy asks for approval, or in an approval stage of the definition, the run waits for a decision from who may approve, with a deadline; approve or reject on screen or through the API, the request reaches the webhooks (Slack included) with the link, and whoever triggered the run cannot approve it.
  • Image builds from the Dockerfile, without a Docker socket or privileged mode, with push by digest to the workspace registry and an image scan as a gate.
Pipeline definition Two stages: the test stage waits for the build, runs in two matrix combinations and publishes JUnit and coverage.
{
  "version": 1,
  "on": { "manual": true, "push": { "branches": ["main", "release/*"] } },
  "stages": [
    { "name": "build", "image": "node22", "steps": [{ "name": "install", "run": "npm ci", "timeout": 300 }] },
    { "name": "test", "image": "node22", "needs": ["build"], "matrix": { "shard": ["1", "2"] },
      "env": { "NODE_ENV": "test" },
      "steps": [{ "name": "install", "run": "npm ci" }, { "name": "test", "run": "npm test -- --shard=$MATRIX_SHARD/2" }],
      "reports": { "junit": ["reports/*.xml"], "coverage": { "format": "lcov", "path": "coverage/lcov.info" } } }
  ]
}

What it does not do

  • GitHub repositories only; a private one needs the AIUBY GitHub App installed on it or a read token in Cortex.
  • The managed executor only accepts the three listed images (node22, python312 and go126), with up to 16 jobs per run and tasks of up to 15 minutes.
  • On the managed executor, the cache covers npm, pip and Go and is only written by trusted triggers (pull requests read, never write); other presets, such as Maven and Gradle, belong to the self-hosted runner.
  • The likely cause comes from rules on the log, with no AI model; the AI explanation is requested step by step, counts toward the workspace AI usage and is a suggestion that never changes the code or the pipeline.

Progressive Delivery

A new version gets traffic gradually and rolls back on its own

Progressive Delivery releases a new Compute revision as canary or blue-green, through Cloud Run traffic splitting. In canary, the revision comes up next to the stable one at 0% and advances in steps (10%, 50% and 100% by default), each observed for a while before the next. In blue-green, the candidate gets its own address for verification and receives 100% at once.

At each step the platform reads the revision's health, error rate, p95 latency and the service's open incidents. A bad signal aborts: all traffic goes back to the stable revision.

How it works

  • Configurable thresholds per rollout: maximum error rate, maximum p95 latency, minimum requests to judge and abort on incident.
  • Optional manual gate: the rollout pauses before each promotion until a person promotes it.
  • Before 100%, policy as code decides (compute.rollout.promote action, per environment): it can require approval from a workspace owner or admin, or deny.
  • Workspace change window (days, hours and time zone): outside it no promotion happens, not even a manual one. Aborting is always allowed.
  • Pause, resume, promote and abort from the signed-in area, the API and the CLI, with every command in the audit log.
  • An abort can open an incident linked to the service, and the delivery graph records the strategy, step and percentage of each deployment.
Through the API Starts a canary in three steps, with five minutes of observation at each, and requires approval before 100% in production.
POST /api/platform/compute/apps/{app}/rollout
{"strategy": "canary", "steps": [10, 50, 100], "observeSeconds": 300, "manualGate": false, "environment": "production"}

# policy rule: production only reaches 100% with approval
{ "id": "aprovar-100", "action": "compute.rollout.promote", "scope": "environment:production",
  "effect": "needs_approval", "reason": "Production requires approval" }

What it does not do

  • It requires the application to be running and the new revision to be in the same region: switching from CPU to GPU changes region and uses direct deployment.
  • Errors and latency are only judged with the minimum number of requests in the step (20 by default); with fewer, the step passes and the reason records the lack of traffic.
  • An API key cannot approve promotion: only a workspace owner or admin.
  • It applies to Compute applications; in the customer's Kubernetes cluster, canary is by replicas, in Kubernetes & GitOps.

Kubernetes & GitOps

A commit on the environment branch becomes a rollout in your cluster

Kubernetes & GitOps delivers to the customer's Kubernetes cluster from a manifests folder in a connected repository: YAML files plus a kustomization.yaml with images and replicas. The platform renders, checks, computes the diff against the live version and drives the rollout.

An agent installed in the cluster fetches the desired state over outbound HTTPS and applies only in the environment namespace. AIUBY stores no cluster credentials and there is no command channel: the response to the agent is only a list of objects, which it checks again, locally, against the same policy.

How it works

  • Rolling or replica-based canary rollout (stable and candidate side by side), with steps, readiness reported by the agent, abort on incident and a manual gate.
  • Policy as code and change window before 100%; customer manifest rules in the policy block the sync and the release stage; aborting returns the cluster to the stable version.
  • Application generator: a template and a list of environments become one application per environment, each created by the same rules.
  • Closed list of kinds (Deployment, Service and ConfigMap) and fields: pods without a cluster API token, without root, without host access and on the restricted profile; a Secret in Git is refused.
  • Drift reported every cycle on replicas, image, ConfigMap, ports and selector; reapplying is an agent option.
  • Rollouts in a production environment feed DORA in Engineering Intelligence: frequency, failure rate and lead time by commit.
Application kustomization.yaml The accepted subset: folder resources, image override and replica count. Any other field is refused, by name.
resources:            # .yaml files from the folder itself (up to 30; no "..", no remote address, no folders)
  - api.yaml
  - config.yaml
images:               # same rule as kustomize: matches by name, without tag or digest
  - name: registro.exemplo/acme/api
    newTag: "1.4.2"   # or newName, or digest: sha256:...
replicas:
  - name: api
    count: 4

What it does not do

  • It does not render Helm: Helm users commit the output of helm template to the environment folder.
  • From kustomize, it only accepts resources, images and replicas; kustomize patches, bases and generators are refused.
  • It does not deliver Ingress, Job, StatefulSet, Secret or persistent volumes: only Deployment, Service and ConfigMap.
  • Canary is by replica ratio, approximate; there is no traffic-based canary (service mesh or ingress) and no reading of error rate and latency from the cluster.

Release Orchestration

One release, several environments, a gate before each one

Release Orchestration treats a release as a set of applications promoted through environments in order, for example dev, staging and production. A stage only starts with every gate open: freeze, change window, policy as code, passing E2E suite, scan with no open critical finding, resource queue, database migration and approval.

The release is pinned to its content. On creation, the reference is resolved to the commit SHA, and every stage renders from that SHA, even if the branch moves later. Approval records the digest of the rendered manifests, and the stage only rolls out exactly that digest.

How it works

  • Tests, scan and migration only count for the release commit: a result from another commit does not open the gate.
  • Resource queue: the stage waits for a rollout from another source on the same applications and for the oldest release in the same environment, first come first served; approval does not jump the queue.
  • Database gate: the stage only rolls out once the migration for the specified database has been applied, with no violations, on the release commit.
  • Four eyes: whoever created the release cannot approve it. In a production environment, only a workspace admin approves, in the UI.
  • Gates are checked again in the same transaction that opens the rollouts; a freeze holds the stage and no approval overrides it.
  • A single timeline with every gate, rollout and decision, and tracing by Jira key: CI runs, pull requests and releases that mention the item.
Through the CLI Exit codes let a CI job wait for approval or stop when a gate closes.
aiuby releases get <release>                # --json; exit 0 completed, 7 in progress or awaiting approval, 6 gate closed, 1 failed or rolled back
aiuby releases approve <release>            # key with delivery:approve; production only in the UI
aiuby releases rollback <release> --reason "checkout error"   # key with delivery:rollback

What it does not do

  • It applies to Kubernetes & GitOps applications; Compute applications do not take part in releases.
  • Releases are created in the UI: the API and CLI query, approve and roll back.
  • An API key cannot approve a production environment or a stage where policy requires a person's approval.
  • The test gate reads the Test Automation Playwright suite; it does not read results from other testing tools.

Deployment Governance

Freeze, four-eyes approval and a required change ticket

Deployment governance decides who can put what live, and when. A time-bound freeze refuses Compute deployments, holds Kubernetes release stages and blocks pipeline runs from push, schedule or manual trigger, depending on the targets chosen. No approval overrides a freeze: it can only be canceled, and the cancellation stays in the history.

Before each Compute deployment, policy as code (compute.deploy action) answers whether it can proceed, is denied or needs approval. The approval request is bound to the application, the revision and the configuration hash, and only another person decides. The workspace rule can require a minimum number of approvals, an approver group and an approved change ticket in Jira or ServiceNow.

How it works

  • Freezes of up to 90 days, for all applications or a list, with Compute, Kubernetes and pipeline targets; pull requests keep running, because they verify and do not deliver.
  • The requester cannot approve, nor can whoever created the key that made the request; an API key never approves. An approval is valid for 24 hours and is consumed by a single deployment.
  • A minimum of N approvals with one vote per person and an approver group; a single rejection decides, and freezes and denying policies win.
  • Change ticket as a condition: until the ticket is approved in Jira or ServiceNow, nobody can approve in AIUBY; rejected there, rejected here.
  • A screen with the request queue for the whole workspace ("x of N"), approve and reject with a note, and freezes that are active, scheduled and in the history.
  • Every request, decision and freeze becomes an event on the signed webhooks, including in Slack format.
Freeze and approval rule Freezes all three targets for the period and requires a person's approval for every deployment made with an API key.
POST /api/platform/compute/freezes
{"name": "...", "startsAt": "...", "endsAt": "...", "apps": [], "targets": ["compute", "k8s", "pipelines"]}

{ "id": "ci-aprova", "action": "compute.deploy", "scope": "app:*", "effect": "needs_approval",
  "conditions": [{ "path": "byCredential", "op": "eq", "value": true }], "reason": "Key-based deployment requires approval" }

What it does not do

  • Approving does not deploy: the requester deploys again within the validity period.
  • Change tickets and quorum apply to Compute deployment requests; Kubernetes releases use release approval.
  • A freeze covers an absolute period, with no recurrence, and does not hold GitOps sync outside a release.
  • Creating and canceling freezes is reserved for admins, through the UI or the session; an API key cannot freeze.

Delivery Controls

Every delivery step checked before it moves on

Delivery controls are the safeguards between code and production, outside the major stages. They decide whether a dependency can be installed, where an artifact came from, which version of an infrastructure module is used, in what order releases compete for the same environment and which tests count.

Everything uses what the platform records: CI JUnit history, pipeline runs, the artifact registry, managed IaC and the database registry. Every new rule and every block goes into the audit log under its own name.

How it works

  • Dependency firewall by ecosystem and package, checked by CI before installing and also enforced in the npm proxy.
  • Provenance: a registry version bound to the successful run, the commit and the digest.
  • Versioned, immutable IaC modules, and IaC plans requested by the pipeline on the run commit; apply proceeds with approval.
  • Tests: quarantine with an expiry, splitting into N parts by duration and selection by what changed.
  • Releases: resource queue, database gate and an application generator from a list of environments.
  • Tracing a Jira item: CI runs, pull requests and releases that mention the key.

Example use case

After a malicious package is published on npm, the platform team creates a rule that blocks the package in every version. CI refuses the install with the reason, the npm proxy hides the version from the metadata and the audit log shows every attempt. That same week, a production release waits in the queue because an older release holds the same environment, and only rolls out after the database migration shows as applied on its commit.

What it does not do

  • The firewall does not use regular expressions: it matches an exact name or a prefix.
  • Test selection is by name; a file without a related test triggers the full suite, and quarantine lasts at most 90 days.
  • A plan requested by the pipeline applies nothing.
  • The application generator creates the applications once; it does not keep them in sync with the list afterward.

Repositories

Your GitHub repositories connected, searchable and with status

Repositories brings together what the platform does with the GitHub repositories connected to the workspace. The connection uses the workspace's own read-only token, which also opens private repositories, and links each repository to the delivery graph, Pipelines and the scanners. The code stays on GitHub: AIUBY does not host Git, and clone and push stay there.

With the option turned on in the pipeline, each run publishes its state on the commit as an aiuby/<pipeline> status check, which GitHub branch protection can require before merge. Code search indexes the text files on the default branch and returns the matching lines, through the UI, the API and a repository CLI.

How it works

  • Commit status from pending to success, failure or error, sent through a dedicated queue with retries: the call to GitHub never holds up the CI run.
  • Full-text search on the default branch, with the repository and matching lines; the index only downloads what changed since the last read.
  • node_modules, vendor, dist, build and files above 200 KB are left out of the index, with up to 3,000 files per repository.
  • aiuby-repo CLI, with no dependencies, using an engineering read key: it lists connected repositories and searches by text, with a repository filter.
  • Each connected repository feeds Engineering Intelligence PR metrics and tracing of Jira items mentioned in commits and pull requests.

Example use case

A team wants the main branch to accept merges only with a green AIUBY build. They turn on status checks in the pipeline and mark aiuby/build as required in GitHub branch protection. While investigating a bug, the platform engineer runs aiuby-repo search "createInvoice" and sees which repositories and lines the function appears in, without cloning anything.

What it does not do

  • It does not host the code: repositories stay on GitHub.
  • Results go back to GitHub as a commit status, not as a check run with per-line annotations.
  • Search only covers the default branch and is text-based, without understanding language symbols.
  • The connection, status checks and search only support GitHub repositories.

Infrastructure as Code

Plan and apply with approval, state in your bucket

Infrastructure as Code runs tofu plan and tofu apply (OpenTofu) in the AIUBY isolated executor, with the customer's cloud identity and state backend. An IaC workspace combines repository, branch or tag, directory, environment, backend, identity and variables, with roles for who runs and who approves, variables inherited from the environment and input sets applied in order.

The plan is evaluated by IaC Review and by the environment policy and then discarded: the findings, impact, decision and hash remain. Apply only happens from a reviewed plan, by its hash, on the plan's exact commit and with human approval. The pipeline can request a plan for its own commit, and the result can come back as a pull request comment.

How it works

  • State always in the customer's S3 or GCS backend, with locking; short-lived federated identity, with plan and apply roles that must be different.
  • Approval by a workspace admin who did not request the plan; required in production and for every request made with an API key. A plan is valid for 24 hours and applies at most once.
  • Queue per IaC workspace: up to 3 runs waiting their turn, promoted in order when the previous one finishes.
  • Ephemeral workspaces with their own state and a lifetime of up to 7 days, to test a change without touching the fixed environment.
  • Module registry with immutable versions pinned to the commit, used as a git::...?ref=<sha> source; graph services within the plan's blast radius.
  • Scheduled or on-demand drift, read-only; detected drift can become a Code Automation task in the IaC repository, with a plan approved by a person before any patch.
Through the CLI A key with the iac:run scope triggers and tracks; it does not approve or register. A blocked plan exits with code 6, and one awaiting approval with 7.
aiuby iac plan --workspace <slug> --wait
aiuby iac runs <id>
aiuby iac apply <id> --plan-hash <hash> --wait

# drift, read-only
aiuby iac plan --workspace <slug> --drift

What it does not do

  • It does not run Terraform: OpenTofu only.
  • It does not create roles in the customer cloud and does not import resources; cost is an estimate from list prices, not the bill.
  • It supports AWS and GCP, with S3 or GCS backends; Azure and other backends are not supported.
  • An expired ephemeral workspace with applied resources is not destroyed automatically: it is flagged for a person to destroy.

Database DevOps

What was applied to each database, with a gate before applying

Database DevOps registers the customer's databases per environment and the history of applied migrations. CI asks the gate before applying, applies with the tool the team uses and reports the result; AIUBY stores no connection string or database credentials.

For Flyway and Liquibase in SQL, the customer's self-hosted runner reads the changelog from each environment's branch, builds the plan with the hash of what will run and applies it after another person approves; if a migration fails, it rolls back the ones already applied in the batch. A migration can also be written by AI from a request: it goes through the SQL rules and only proceeds after review by another admin.

How it works

  • Rules per database: rollback required for every migration, migration check allowed, and promotion order (the version must be applied in the previous environment).
  • A gate before applying with the reason for each refusal, including a version previously applied with different content.
  • History per database: version, state (applied, rolled back, failed), commit, who reported it and the rules broken; versions from the previous environment missing in the next one, side by side.
  • Schema diff between two databases (tables, columns, indexes and primary key), from snapshots sent by CI or read through the data connector with verified TLS, catalog only and never rows.
  • Runner-applied migrations with approval bound to the plan hash; freezes and denying policies win over approval.
  • The same record opens the database gate for releases: the stage only rolls out with the migration applied on the release commit.
In CI, through API v1 A key with the db:report scope for the gate and the report, and db:read for reading. The gate applies nothing: it answers whether you can.
# before applying
POST /api/v1/db/migrations/gate
{"database":"contas-prod","migrations":[{"version":"V12","hasRollback":true,"checkId":"<id>"}]}

# after applying with your tool
POST /api/v1/db/migrations
{"database":"contas-prod","version":"V12","hasRollback":true,"commit":"<sha>"}

GET /api/v1/db/schema-diff?from=contas-stg&to=contas-prod

What it does not do

  • It does not simulate SQL; the customer's CI or runner executes it, with the connection stored only there.
  • The history is what CI and the runner report; a migration applied outside them does not appear.
  • An AI-written migration is never applied without review by a person other than the requester.
  • SQL risk analysis in CI is a separate feature: Database Migration Review.

IaC Review

Dangerous infrastructure changes stop in CI, with the reason

IaC Review analyzes Terraform and OpenTofu changes in CI. It reads the PR's .tf files or, preferably, the plan JSON that the customer's CI generated with its own credentials, and returns findings, impact and the environment policy decision.

The plan is analyzed in memory and only the findings are stored, with secret values redacted. CI gets a gate: proceed, proceed with a warning, wait for approval in the UI, or blocked.

How it works

  • Nine rules: resource removed, force_destroy, prevent_destroy removed, database or cache class change, 0.0.0.0/0 ingress, public bucket, literal secret, replacement and deletion_protection turned off.
  • Only what is new relative to the base counts, with higher severity when the resource stores data or the port is administrative or a database port.
  • Risk score from 0 to 100 and plan impact: what it creates, changes, removes and replaces.
  • Decision by policy as code (iac.apply action, per environment), always the more restrictive of the base gate and the policy.
  • Drift: CI records the apply, and a subsequent plan with changes outside the code, or with changes on the same commit as the recorded apply, is flagged.
  • Approval in the UI by a workspace admin, never by the requester, with a justification.
In the pipeline Exit codes: 0 cleared (including warnings), 6 blocked, 7 awaiting approval.
terraform plan -out plan.out
terraform show -json plan.out > plan.json
aiuby iac check --env production --workspace core --commit "$GITHUB_SHA" --plan plan.json infra/*.tf --base origin/main

# after CI applies, record the drift baseline
aiuby iac applied --env production --workspace core --commit $SHA

What it does not do

  • It does not run terraform, store state or the plan, or access the customer cloud.
  • Without the plan JSON, the reading is text-based: it does not resolve variables, count, for_each, dynamic blocks or remote modules.
  • It does not write comments or checks on the PR and does not estimate cost in money.
  • Drift depends on a scheduled plan in the customer's CI: there is no direct cloud reading.

Database Migration Review

An irreversible DROP shows up in the PR, not in production

Database Migration Review analyzes SQL migration files in CI, without connecting to the customer database. It flags operations that destroy data, lock tables or break the previous application version, and decides based on the environment policy.

The result is the same gate as infrastructure reviews: CI proceeds, proceeds with a warning, waits for approval in the UI or is blocked, with the risk score and every finding explained.

How it works

  • Thirteen rules for Postgres: DROP of tables and columns, TRUNCATE, type change with rewrite, NOT NULL without DEFAULT, index without CONCURRENTLY, rename, FK or CHECK without NOT VALID, long locks and UPDATE or DELETE without WHERE, among others.
  • Expand and contract in the same delivery and migrations without rollback are flagged, when the change has rollback files or the request requires them.
  • Large tables declared in the request raise the severity of findings on them.
  • Rollback sections and files (down, rollback) are not evaluated as destructive, and a table created in the same migration does not trigger index or constraint findings.
  • Decision by policy as code (db.migrate action, per environment), with approval in the UI by an admin, never by the requester.
In the pipeline Analyzes new migrations relative to the base, requires a rollback file and waits up to ten minutes for approval.
aiuby db check --env production db/migrations/*.sql --base origin/main --large-tables orders,events --require-rollback --wait 600

What it does not do

  • It does not apply migrations or compare schemas across environments.
  • It does not connect to the database: table size is only what the request declares.
  • MySQL coverage is basic, and procedures (DO blocks) are not analyzed.

Self-hosted Runner

CI jobs on your network, with caching and metrics

The self-hosted runner is an agent that runs on a customer VM or Kubernetes cluster and pulls work from AIUBY over outbound HTTPS, with a key of its own. A pipeline stage with runsOn goes to the runner that has those labels; variables stay encrypted per job and the result comes back through the same signed callback as the managed executor.

The same runner executes Ansible playbooks (with --check --diff by default) and applies approved Flyway and Liquibase migrations, with the target credentials stored only on its machine. AIUBY sends what to run; the connection to the database and the servers never goes through it.

How it works

  • One key per runner: revoking the runner revokes the key, and a picked-up job stays bound to it and to the organization.
  • Fork pull requests are blocked before dispatch and never reach the runner; pull requests only read the cache, which only trusted triggers write, scoped to the branch.
  • Up to 4 auxiliary services (such as a Postgres) on the same network as the job, plus CPU and memory for each build.
  • Per-tool cache: npm, pnpm, yarn, pip, Go, Maven and Gradle, capped at 500 MB per workspace.
  • Step plugins from a closed catalog: parameters become PLUGIN_ variables and never go into the command.
  • A migration only runs after another person's approval bound to the plan hash, in a transaction, and the batch is rolled back if one fails.

Example use case

A team with its database and services on a private network registers a runner with the linux and docker labels and points the test stage to it. The integration test spins up a Postgres next to the job, the npm cache shortens the install, GitHub shows the result on the commit and the reviewed migration goes out through the same runner, without the database password passing through AIUBY.

What it does not do

  • The job executor is the AIUBY CI image running on the runner's Docker; GitHub actions do not run as steps.
  • The cache lives in the platform database, capped per workspace; there is no remote Gradle or Bazel cache.
  • The runner is not an installation of the whole platform on your network: AIUBY remains the control plane.

Artifact Registry

Images and packages with an owner, proven provenance and retention

Artifact Registry gives each workspace Docker and npm repositories in the AIUBY Google Artifact Registry, in São Paulo, the same region as Compute. Access uses a 15-minute push or pull credential, issued for a service account restricted to the organization's repositories.

The catalog shows each version with digest, tags, size, date and publisher, and links the artifact to the repository and commit in the graph. Provenance binds a version (image, package or AI model) to the successful pipeline run that produced it, the commit and the digest. On Compute deployment, a gate refuses an image without a scan or without a verified signature when the workspace requires it.

How it works

  • One cloud repository per platform repository, with permission only on it: one organization's token cannot open another's repository.
  • cosign signatures verified with the workspace ECDSA P-256 public key: a signature from another image, another key or a tampered one is marked as invalid.
  • Dependency firewall: rules by ecosystem and package (exact name or prefix), checked by CI before installing, with every block in the audit log.
  • npm proxy: the team's npm points to AIUBY, which fetches from the public registry, caches per workspace and hides versions blocked by the firewall.
  • Policy-based retention (last N versions, untagged after X days), without deleting the most recent or an image in use; a published or removed version becomes a webhook event.
  • Per-repository access log read from Cloud Logging, and repositories and accounts deleted in the cloud when the organization is closed.
Publish an image The credential is valid for 15 minutes and only opens the organization's own repositories.
aiuby artifacts login
echo "$AIUBY_REGISTRY_TOKEN" | docker login -u oauth2accesstoken --password-stdin https://southamerica-east1-docker.pkg.dev
docker push southamerica-east1-docker.pkg.dev/<project>/<repository>/api:1.2.0

What it does not do

  • It supports Docker and npm; Maven and PyPI are not supported, not even in the proxy.
  • cosign verification is key-based: it does not check keyless signing, the transparency log or the new bundle format.
  • Provenance is a platform record, not a signed attestation.
  • Isolation between workspaces in the same organization is logical: the credential belongs to the organization account.
Preview

Destinos de deploy

The approved commit reaches your cloud, server or Vercel

Preview: in internal validation; when it opens, access is granted per organization.

Destinos de deploy (deploy targets) take the artifact CI approved (the image by digest, or the commit) outside Compute: a service on ECS in the customer AWS account, a plain Linux server or a Vercel project. The target only receives what passed the pipeline gates.

On AWS, the customer creates a role from a CloudFormation template provided by AIUBY, with an ExternalId unique to the organization; AIUBY assumes that role for a short time and stores no account key. On a server, an agent installed with one command pulls orders over outbound HTTPS, with no open port.

How it works

  • AWS: the image is copied to the customer ECR with the same digest and deployed to ECS Fargate; bad health during delivery stops the deployment and rolls back to the previous version.
  • Linux server: the agent pulls the image by digest, swaps the container, checks health and rolls back on its own if health fails.
  • Vercel: AIUBY creates the production deployment for the approved commit, follows it until ready and sends traffic back to the previous deployment if health fails.
  • Rolling back to the previous version is also an action in the app and the API, with the reason recorded.
  • Every delivery, rollback and credential change is in the audit trail; the Vercel token is stored encrypted in the database.

Example use case

A team running its application on AWS connects the account with the CloudFormation template, registers the service as a target, and from then on every commit approved by CI, the scan and the tests is deployed to ECS, with automatic rollback if health drops.

What it does not do

  • On AWS, deploys only to ECS Fargate.
  • On a server, requires Linux with systemd and Docker.
  • On Vercel, Vercel builds from the approved commit; the CI image is not used.

Governance and security

Rules the code enforces

  • Compute secrets are encrypted before they reach the database. The value never comes back through the UI, API, logs or audit trail.
  • Monthly Compute cap per workspace: when it is reached, the application stops within minutes instead of running up a surprise bill.
  • Paid deployments require a prepaid account with a balance and a defined cap. The application endpoint can require an access token.
  • Promotion to 100% goes through policy as code and the workspace change window. Nothing is promoted outside the window, and aborting is always allowed.
  • Requesters do not approve: Compute deployments with approval, releases and infrastructure applies require a second person, and in production approval always comes from a person, never from an API key.
  • Time-based freezes for Compute, Kubernetes and pipelines that no approval overrides. The rule can require N approvals, an approver group and an approved change ticket in Jira or ServiceNow.
  • Pull requests from forks never reach the self-hosted runner or receive secrets. Dependencies blocked by the firewall are rejected in CI and in the npm proxy.
  • AIUBY does not store infrastructure state or plans. Runs use short-lived federated identity in the customer's cloud, with separate plan and apply roles.
  • On Kubernetes, the agent only makes outbound connections and applies a closed list of resource types in the environment namespace. AIUBY does not store cluster credentials.

Integrations

What it connects to

Only integrations that exist in the code. Each one carries the status of the feature that uses it.

  • Google Cloud RunRuns Compute runtime applications on CPU and GPU.Compute runtime
  • Public CLIDeploy, view logs, write secrets and check billing from the terminal (@aiuby-ia/cli).Compute runtime
  • GitHubA push to the branch triggers the pipeline, through a webhook with a verified signature.Pipelines
  • Cloud MonitoringError rate and p95 latency of the candidate revision at each rollout step.Progressive Delivery
  • KubernetesAn agent in the customer cluster, with minimal RBAC in the environment namespace.Kubernetes & GitOps
  • OpenTofuManaged plan and apply, with state in the customer's S3 or GCS.Infrastructure as Code
  • AWS and Google CloudOIDC federated identity for infrastructure runs, with no long-lived keys.Infrastructure as Code
  • TerraformReads .tf files and the plan JSON generated in the customer's CI.IaC Review
  • Postgres and MySQLAnalysis of SQL migration files, without connecting to the database.Database Migration Review
  • Docker and npmPer-workspace repositories on Google Artifact Registry, in São Paulo.Artifact Registry
  • cosignImage signatures verified against the workspace public key.Artifact Registry
  • GitHub status checksPipeline results published on the commit, which branch protection can require.Repositories
  • Jira and ServiceNowAn approved change ticket as a condition for deployment approval.Deployment Governance
  • SlackDeployment and CI events through webhooks, in Slack format.Deployment Governance
  • AnsiblePlaybooks run by the self-hosted runner, with --check --diff by default.Self-hosted Runner
  • Flyway and LiquibaseSQL changelogs applied by the runner after approval by hash.Database DevOps

FAQ

Straight answers

What can I use today?

Available: Compute runtime, Pipelines, Progressive Delivery, Kubernetes & GitOps, Release Orchestration, Deployment Governance, Delivery Controls, Repositories, Infrastructure as Code, Database DevOps, IaC Review, Database Migration Review, Self-hosted Runner, Artifact Registry. Preview: Destinos de deploy. Self-service: add it from your account.

Can it run inside my company network?

Available: Compute runtime, Kubernetes & GitOps. The Compute runtime cannot: it runs on Google Cloud, in an account operated by AIUBY. To deliver to your own cluster, use Kubernetes & GitOps: an agent installed in the cluster pulls the desired state over outbound HTTPS and applies it only in the environment namespace, and AIUBY stores no cluster credential.

Does Software Delivery build and test my repositories?

Available: Pipelines, Self-hosted Runner, Repositories. Pipelines runs builds and tests on isolated runners, with Node, Python and Go images, a matrix, secrets, JUnit reports, coverage and test policy, triggered by push, pull request, schedule or manual run. It also builds the image from the Dockerfile and pushes it to the workspace registry. The managed runner serves public and private GitHub repositories. To run inside your network, with service containers and caching, the stage moves to your self-hosted runner, and the result comes back as a status check on the GitHub commit.

How is Compute billed?

Available: Compute runtime. By the time each replica is in use and by network egress, drawn from the prepaid balance, with no monthly fee. On CPU, a stopped or idle application costs nothing. With GPU, billing is per minute the instance is on, idle or not. The hourly price of each size is on the Pricing page, the current rate shows in your account before you deploy, and the workspace monthly cap limits the total. Without a prepaid account with a balance and a defined cap, the deployment is refused with the reason.

Does AIUBY access my cloud, my cluster or my database?

Available: IaC Review, Database Migration Review, Infrastructure as Code, Kubernetes & GitOps. Not in the CI reviews: IaC Review reads the PR files or the plan JSON your CI produced, and Database Migration Review reads the SQL files without connecting to the database. In managed infrastructure, plan and apply run with a short-lived federated identity that your cloud authorizes, and the state stays in your bucket. On Kubernetes, the agent inside your cluster is what applies changes.

Does it work with Terraform and Helm?

Available: IaC Review, Infrastructure as Code, Kubernetes & GitOps. IaC Review analyzes Terraform and OpenTofu changes. Managed plan and apply run OpenTofu only, not Terraform. Helm is not rendered: Helm users commit the helm template output to the environment folder, and from kustomize only resources, images and replicas apply.

Who approves a production change?

Available: Deployment Governance, Progressive Delivery, Release Orchestration, Infrastructure as Code. Always a person who administers the workspace, and never the requester. For Compute deployments, policy decides whether approval is needed, and the rule can require N approvals, a group and an approved change ticket in Jira or ServiceNow. During a freeze, nothing gets through. In a Compute rollout, policy decides whether reaching 100% needs approval. In a release, the creator cannot approve, and the approval covers the exact content that was reviewed. For infrastructure applies, approval is mandatory in production and for every request made with an API key. No AI model decides promotions, approvals or applies.

Where is my application data stored?

Available: Compute runtime, Artifact Registry, Infrastructure as Code. Compute applications run on Google Cloud in the São Paulo region. Images and packages in the artifact registry stay in the same region. Configuration, revisions and deployment records stay on the AIUBY platform, and secrets are encrypted in the database. Infrastructure state always stays in your backend.

Works together with

  • Security TestingThe commit scan is a release gate: an open critical finding holds promotion to the next environment.
  • Incident ManagementAn open incident on the service during a rollout aborts the promotion, and the abort can open an incident linked to the service.

Software Delivery

Self-service: add it from your account.