Skip to content

One common layer for every product

Platform

One login, one set of rules per workspace, one exit point to the models, one isolated executor and one record, shared by all twelve products, from code to operations. Policies and pipelines are versioned in Git, a second person approves where a change matters, and the audit trail flows to your SIEM. The AI usage policy covers chat, agents and API calls; the UI, the API, the CLI and the MCP server use the same scoped key.

Map

The products on one foundation

updated

Understand

  • Engineering Intelligence
    • PR flow
    • PR review
    • Code Review
    • Delivery metrics
    • DORA metrics
    • Teams and goals
    • Graph questions
    • AI efficiency
  • Developer Portal
    • Engineering standards
    • Service catalog
    • Scorecards
    • Self-service
    • Portal adoption
    • Portal extensions

Build and ship

  • AI Engineering
    • Agent Management
    • Specialist & worker agents
    • Agent governance
    • Agent operations
    • Workflows
    • Evals
    • Prompt & config registry
    • Knowledge bases
    • Models & Gateway
    • Skills registry
    • Execution traces
  • Software Delivery
    • Compute runtime
    • Pipelines
    • Progressive Delivery
    • Destinos de deployPreview
    • Kubernetes & GitOps
    • Release Orchestration
    • Deployment Governance
    • Delivery Controls
    • Repositories
    • Infrastructure as Code
    • Database DevOps
    • IaC Review
    • Database Migration Review
    • Self-hosted Runner
    • Artifact Registry
  • Code Automation
    • Ticket to PR
    • Code context and verification
    • Code experts and event-driven flows
  • Feature Management
    • Feature flags
    • Experimentation
    • Runtime configuration
    • Warehouse experiments
    • Release monitor and flag cleanup
  • Test Automation
    • E2E tests
    • AI test authoring
    • Visual regression
    • Composable test plans
    • Conditional, data and AI steps
    • GitHub Actions, Jira and recording

Protect

  • AI & API Security
    • AI Firewall
    • Prompt Injection Detection
    • AI Posture
    • AI Security Testing
    • API Posture
    • API Security
    • API Protection
    • MCP Firewall
  • Security Testing
    • SAST
    • SCA
    • Supply Chain Security
    • Scanner Orchestration
    • Finding Risk
    • External Findings
    • Application DAST
    • Security Governance

Operate

  • Cost Management
    • AI Costs
    • Billing
    • Compute Costs
    • AI Tool Seats
    • Cloud Costs
    • Optimization
    • Cost allocation
    • AutoStopping
  • Incident Management
    • SLOs & error budgets
    • Incidents
    • On-call & runbooks
    • Incident response
    • Status page
  • Resilience Testing
    • Resilience risk scan
    • Chaos experiments
    • Load testing
    • Disaster recovery drills
    • Resilience insights

End to end

From code to production, and from production to operations

Six stages on the same foundation of rules, context and audit. Each product shows up where it acts and links to its full page.

  1. Understand

    What exists, who owns it and how delivery is going.

  2. Build

    Agents, models and AI-proposed code, reviewed by a person.

  3. Verify

    AI-assisted tests, security analysis prioritized by risk and a CI gate before any promotion.

  4. Ship

    Pipelines on the managed runner or on yours, artifacts with provenance, infrastructure and rollouts with freezes, policy and approval.

  5. Protect

    AI, APIs and MCP calls in production, with sensitive data handled before it reaches the model.

  6. Operate

    Incidents in your team's Slack, chaos and load with rollback, and costs, all tied to the changes that caused them.

Underneath

What runs underneath, and the rules that apply to all

First the core every account uses. Then the shared governance: deployments, policies, MCP calls and what runs in your environment.

Core layer

  • Model gateway

    Every model call from the products goes through a single point, with models enabled per workspace and cost recorded.

    Models & Gateway

  • Rules per workspace

    Roles, scoped keys and a sensitive data policy, all versioned.

    Governance & policies

  • Agents with approval

    When an agent reaches a tool with side effects, it stops and waits for a person to decide.

    Agent Management

  • Hash-chained audit

    Each record points to the previous one by hash; a public script verifies the export.

    Audit

Shared governance

  • Delivery graph

    Connects repositories, services, changes, environments and AI assets, and keeps the source of every data point.

    Knowledge Graph

  • Governance in Git

    Policies and pipelines are exported and imported with a plan before they apply; a policy proposed by AI only takes effect with approval, after a replay of recent decisions.

    Platform governance

  • Deployment with rules

    A freeze that no approval can override, an approver quorum and a change ticket, for Compute, Kubernetes and pipelines.

    Deployment Governance

  • Firewall for MCP calls

    Deny-only rules, a response baseline, sensitive data masking and SIEM events around every MCP tool.

    MCP Firewall

  • Runner in your environment

    A pull-based agent with one key per runner: the job runs on your side, and pull requests from forks never reach it.

    Self-hosted Runner

  1. Inputs

    • GitHub repositoriesPull requests and code
    • DocumentsKnowledge bases with per-document permissions
    • Model providersAnthropic, OpenAI and Google Cloud
    • AlertsAlertmanager, Sentry and webhook
  2. Rules and context

    • Delivery graphServices, changes and environments, with their source
    • Policies and rolesWho can do what, per workspace
    • AI firewallSensitive data handled before the model
  3. Execution

    • AgentsTools with side effects wait for approval
    • WorkflowsApproval wherever the step exists
    • Isolated executorDisposable container, no permissions
    • Compute runtimeApplications on Google Cloud Run
  4. Record

    • Hash-chained auditExportable and verifiable outside the platform
    • Cost per callBy model, key and project
Each node carries the badge of the catalog feature it comes from.

The isolated executor

Isolated executor architectureThe platform records the request and the rules, dispatches a disposable container with no cloud permissions that reads the repository or target, and receives a signed result, which it evaluates and records in the audit trail.AIUBY platform1. Request and policywho asked, key scope, rules4. Evaluation and gatefindings, expiring waivers, decision5. Hash-chained audit trailIsolated executor (disposable container)2. Run with a time limitcloud account with no permissions3. Signed resultsingle-use token; the container is destroyedAuthorized repository, image or targetdispatches the jobsigned return
Scans, tests, pipelines and infrastructure plans run outside the platform, in a disposable container. The platform decides what runs and evaluates what comes back. Scanner Orchestration

Controls

Rules the code actually enforces

Each row gives the rule, how it is enforced and its status. What the platform does not do is in the same table.

SituationWhat happensStatus
Tenant separationIn the platform database, every query goes through a per-organization isolation rule (row-level security).Governance & policies
API keyDoes only what its scope allows, inside the workspace where it was created.Governance & policies
Model choiceOnly models enabled in the workspace respond, with restrictions by role, team and person.Models & Gateway
Sensitive dataMasked, refused or allowed before the model, according to the workspace policy.AI Firewall
Agent tool with side effectsStops and waits for a person to decide.Agent Management
Connector in a workflowRuns without approval, including on a schedule, unless the workflow designer placed an approval step before it.Workflows
Repository analysisIn a disposable container, with a cloud account that has no permissions and a time limit.Scanner Orchestration
Published applicationOn Google Cloud Run, with a monthly spending cap per workspace.Compute runtime
Model callProcessed on the provider's servers, which may be outside Brazil; cost is recorded per key and project.Models & Gateway
Action logHash-chained and exportable as CSV and JSON. It proves tampering against a hash stored elsewhere; it is not immutable to whoever administers the database.Audit
Execution on the customer networkThrough the self-hosted runner and the delivery agent, which pull work over HTTPS; the platform itself is hosted by AIUBY.Self-hosted Runner
Deployment during a freezeRefused on Compute, Kubernetes and pipelines; no approval overrides it.Deployment Governance
Agent MCP callGoes through the firewall rules before and the baseline after; an abnormal outcome becomes a signed event.MCP Firewall
Code assistant reading the platformThrough the MCP server, read-only, with the same API key and the same scopes: services, findings, scans, SLOs, incidents, flags, AI cost and published skills.MCP server
Organization AI ceilingAllowed models and providers, minimum masking, blocked tools and a monthly quota apply above the workspaces and are enforced at the gateway, failing closed.Organization AI policy
Code editor extensionAccess is through the UI, the API, the CLI and the MCP server.Not offered

One request, end to end

From request to record

The path of an agent action that changes something outside the platform. Each step carries the status of the piece that runs it.

  1. Request

    Someone asks the agent for a task, in the UI or through the API with a scoped key.

  2. Rules

    The gateway checks that the model is enabled in the workspace and that there is budget; sensitive data is handled before the model.

  3. Work

    The agent reads and builds its proposal using only the tools enabled for its version.

  4. Approval

    The tool with side effects stops and shows what it is about to do. A person approves or rejects; with no decision in time, the action does not happen.

  5. Record

    The decision enters the hash-chained audit trail, which you export and verify outside the platform with a public script.

Approval chainA change starts as a proposal, passes the policy, test, scan and change window gates, waits for another person to decide, runs exactly as approved and is recorded in the audit trail. A rejection or an expired deadline ends the chain with nothing executed.1. Proposalagent, pipeline or person2. Gatespolicy, tests, scan, window3. Decisionanother person approves or rejects4. Executiononly what was approved, by hash5. Recordchained audit trail, exportableRejected or expired: nothing happens
The same chain applies to an agent action, a release promotion and an infrastructure apply: whoever proposes is not whoever approves, and only what was approved runs. Agent Management
The record, as it appears in the export Sample row with fictitious ids, date and hashes. The fields are those of the audit JSON export.
{
  "id": "evt_exemplo_0001",
  "created_at": "2026-11-14T13:02:11.000000Z",
  "action": "agent.approval_approve",
  "actor_type": "user",
  "actor_id": "usr_exemplo",
  "workspace_id": "ws_exemplo",
  "target_type": "agent_run",
  "target_id": "run_exemplo",
  "request_id": "req_exemplo",
  "metadata": {
    "tool": "automation_trigger"
  },
  "chain": {
    "seq": 4182,
    "hash": "9f2c…e41a",
    "prev_hash": "51b7…0c93",
    "content_hash": "d08e…7f22",
    "canonical": "…"
  }
}

Delivery data

Questions with evidence, metrics with a formula

The delivery graph answers in natural language using only what it can cite. Delivery metrics show their formula and window; lead time and MTTR only appear when there is data.

  • Graph questions

    Natural-language questions to the delivery graph, answered only with cited evidence.

  • Delivery metrics

    Deployment frequency and change failure rate with formula and window, lead time from CI to the deployment of the same commit, MTTR when data exists and open security findings per team, with a weekly trend.

  • PR flow

    Weekly PRs, time to merge and open PRs, synced from GitHub.

Interfaces

UI, API, CLI, MCP and webhooks

Much of what you do in the UI you can also do through the API, with a scoped key. The public CLI deploys to Compute and works as a CI gate, code assistants read the platform through the MCP server, and workflows call your n8n with a signed callback.

Shared capabilities

What every product inherits

These are not products for sale: they are the pieces that apply to all of them. Each block covers what the capability does, an example from the documentation and what it does not do.

Governance & policies

Who can do what, in each workspace, enforced in code

The organization is the company on the platform, isolated from all others; the workspace is a division within it, and it owns documents, agents, keys, budget and policy. People join with a role (owner, admin or member); systems join with an API key, which is valid for a single workspace and does only what its scopes allow.

Workspace policies are versioned: what to do with each sensitive data category before a model call, how many requests per minute and concurrent calls, which tools are blocked. The same policy applies to chat, agents and API calls, and every change goes into the audit log.

How it works

  • Roles: the owner manages the whole organization, products and budget; the admin manages the workspace's keys, allowed models and integrations; the member uses the products.
  • API keys scoped by function: a key that can only search knowledge cannot call models or run agents.
  • Keys valid for 90 days by default (up to 365), rotation with an overlap of up to 24 hours and immediate revocation.
  • Sensitive data by category (CPF, CNPJ, card, account, Pix, boleto, secrets, email, phone): block, mask or allow.
  • Per-workspace limits: 60 requests per minute and 20 concurrent calls by default, plus tool blocking.
  • Separation between organizations in the database, through access rules enforced row by row.

Example use case

A company creates one workspace for the support team and another for finance. In the finance workspace, the admin blocks Pix keys and bank accounts in the sensitive data policy and allows only one model. The billing system gets a key with the scope to run flows, and nothing more. When someone changes the policy, the previous and new versions are kept in the audit log with the name of whoever made the change.

What it does not do

  • A key is valid for a single workspace, and each workspace has up to 20 active keys.
  • The audit export scope can only be granted by someone who administers the whole organization.
  • The policy covers what goes through the platform, the browser extension or the perimeter proxy; AI usage outside them is not seen.
  • It does not replace a formal certification.

Audit

A record you can verify outside the platform

Every relevant action in the organization becomes an event: who did it (person, key or system), what, on which target and in which workspace. The application does not change or delete recorded events. Every minute, new events receive a position and a hash: the previous hash combined with the hash of the content.

Changing, inserting or deleting an event in the middle breaks the chain, and verification points to where. The screen checks the chain for the period and shows the latest sealed hash for you to note down; the JSON export includes the chaining of each event, and a public script checks everything without talking to the platform. It is tamper evidence against a hash stored outside.

How it works

  • Events from every product in a single record: agent approvals, policy changes, keys created and revoked, integrations turned on, calls to the MCP server.
  • Export from the UI or the API, with the "Export audit" scope, as paginated JSON or CSV.
  • A public verifier with no dependencies, which runs on Node.js 18 or newer and points to the event where the chain broke.
  • Passing the last hash you noted to the verifier proves the end of the trail did not change either.
  • Optional retention, from 1 to 10 years; when the start of the chain is deleted, a marker with the last deleted hash remains, and verification starts from it.
  • Continuous streaming per workspace to Splunk (HEC) and Datadog Logs, in batches of up to 100, with its own cursor that only advances after confirmation and an encrypted token.
Export and verify Exports the events as JSON, one per line, and checks the chain with the public verifier; exit code 0 means the chain is intact.
curl -sS -H "Authorization: Bearer $AIUBY_TOKEN" \
  "https://aiuby.com/api/platform/audit/export?format=json&from=2026-11-01&to=2026-11-30&limit=5000" \
  | jq -c '.events[]' >> auditoria.jsonl
# repeat with &cursor=<next_cursor> until next_cursor is null

curl -sSO "https://aiuby.com/downloads/verificar-auditoria-aiuby.mjs"
node verificar-auditoria-aiuby.mjs auditoria.jsonl

What it does not do

  • It is not immutability: someone with owner access to the database could recompute the whole chain, and that only shows up when compared with a hash stored outside (the last one noted or an earlier export).
  • There is no automatic external anchor: storing the hash outside depends on an admin noting it down or exporting.
  • Each export covers up to 92 days; CSV does not carry enough to verify the chain.
  • An event can stay unsealed for up to about a minute.

Knowledge Graph

Services, repositories and changes linked, with the source of every fact

The delivery graph connects the pieces of engineering: services, repositories, databases, owners, changes, deployments, environments, security findings, SLOs and incidents. Every entity and relationship records where it came from and when it was last seen, so every answer drawn from the graph can cite its evidence.

It is the common foundation for the service catalog, delivery questions and specialist agents. The platform projects connected repositories and Compute applications automatically, and each workspace only sees its own graph.

How it works

  • Entities with identity resolved by alias and external key: the same service does not appear twice because it came from two sources.
  • Provenance on every fact: source and freshness of the data.
  • An entity's neighborhood up to 3 levels deep, with up to 500 neighbors.
  • Structured query by intent (owners, dependents, affecting findings, incidents, deployments after a change), with no model and no AI cost.
  • Read access through API v1 and the MCP server, with attributes from a closed list and sanitized text, with no secrets.
  • Code, catalog, deployment and SLO events on a shared timeline.
Through API v1 Lists entities by name, reads an entity with its neighborhood, lists recent events and runs the structured graph query.
Base: https://aiuby.com/api/v1
Authorization: Bearer <key>

GET  /engineering/catalog?kind=&q=&cursor=&limit=
GET  /engineering/entities/{id}?depth=1..3
GET  /engineering/events?limit=1..200
POST /engineering/query        { intent, params }

What it does not do

  • The graph only knows what was connected: a repository outside GitHub or a service with no registered owner is left out, and the answer says so.
  • Natural-language questions do not exist in the API: they are asked in the UI.
  • The API is read-only: it does not write entities or relationships.
  • Graph queries are capped at 120 per hour per key.

Connectors & webhooks

The platform calls your systems, and the response comes back signed

Integrations connect a workspace to the company's systems. The company's n8n receives triggers from agents and flows and returns the result signed; the company's MCP servers offer tools that agents use after each one is reviewed; and an agent run can notify your system when it finishes, with a signature.

In every case the platform validates before calling: HTTPS on a public address only, internal network addresses refused on every connection, parameters checked against what was registered, and encrypted secrets that are never shown again after being saved.

How it works

  • n8n: one per workspace, with up to 30 registered workflows, each with a key, webhook path and a closed list of parameters.
  • Triggers carry the secret in the header and a correlation id; the response is signed with HMAC-SHA256 over the timestamp and the body.
  • It only retries when it is certain nothing reached n8n; when in doubt the platform does not repeat, to avoid running twice.
  • MCP servers: up to 10 per workspace, with up to 30 allowed tools each, marked as read or as write with approval.
  • Each MCP tool definition is pinned by hash: if the description or parameters change on the server, the call is not made.
  • Connecting, rotating secrets, registering and removing are recorded in the audit log; secrets never go to the audit log or to the agent.
The trigger your n8n receives The call the platform makes to the registered webhook; the workflow returns the result later, with the same correlation id.
POST https://n8n.suaempresa.com.br/webhook/avisar-financeiro
content-type: application/json
x-aiuby-webhook-secret: n8nwh_...

{
  "correlation_id": "3f6c2c1e-8a41-4b7e-9d53-0c1a2b3c4d5e",
  "workflow": "avisar-financeiro",
  "parameters": { "valor": 1250.5, "motivo": "Refund for order 4471" }
}

What it does not do

  • AIUBY does not host n8n: the instance belongs to the company, and there are no ready-made connectors for other automation tools.
  • MCP servers over HTTP only, with a fixed token or no token: there is no OAuth or local stdio connection.
  • An MCP tool with nested or list parameters cannot be allowed.
  • Registration happens in the UI: there is no API key route to connect n8n or an MCP server.

API, CLI & keys

Scoped keys for your systems and a public CLI

Every key-based route requires an API key with the matching scope, sent in the authorization header. There are three families: the model Gateway, compatible with the OpenAI SDK; the platform routes, to search knowledge, run agents, prompts and flows, export the audit log and operate Compute; and the engineering API v1, read-only, with an OpenAPI 3.1 contract.

The public CLI, @aiuby-ia/cli (version 0.9.0), uses the same keys: it registers, deploys and tracks applications on Compute, stores secrets, reads logs and statements, and prints the MCP server configuration block for your coding client.

How it works

  • One scope per function: call models, search or upload to knowledge, run agents, prompts or flows, export audit, read, manage or deploy on Compute.
  • API v1 with a single envelope for data, error and metadata, an opaque cursor and stable error codes: no key, 401; without the route scope, 403.
  • A Terraform module that declares load test scenarios through API v1, with the generic restapi provider and a key scoped to load-test:run.
  • v1 limits: 120 requests per minute per key and 300 per minute per workspace, with the wait time returned in the response.
  • The CLI stores the key after checking it with the API; it does not appear on screen or in the terminal history.
  • Everything a key does is recorded in the audit log under its name.
Through the CLI Signs in with an API key, checks the organization and workspace and prepares a Compute application.
aiuby login       # paste the key; it does not appear on screen
aiuby whoami

aiuby init fastapi-http minha-api   # copies a starter template
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

What it does not do

  • No API key can approve an agent or flow action: approval always belongs to a person, in the UI.
  • A browser session does not work with API v1: only a key, in the exact header format.
  • There is no public embeddings route for API keys.
  • The CLI has no commands for agents, flows, knowledge or skills.

Organization AI policy

An AI ceiling that applies to every workspace

The organization AI policy sits above each workspace's policies. It defines which models and providers can be used, whether data can be sent for processing outside Brazil, the minimum masking per sensitive data category, blocked tools and a monthly call quota summed across workspaces.

The effective policy is the intersection: the organization restricts, and the workspace can only restrict further. The rule is enforced in the Gateway, at the same point as the workspace policy, before reserving balance and before calling the provider. Beyond the ceiling, the organization writes the AI rules: a versioned text that goes in as a system instruction in every chat and agent response.

How it works

  • A model or provider outside the organization list does not run, even if allowed in the workspace, and this also applies to the fallback model.
  • With sending outside Brazil turned off, only candidates whose known region is in Brazil pass; an unknown region counts as outside.
  • Sensitive data: per category, the stricter action between organization and workspace applies (block, then mask, then allow).
  • Fail closed: a policy saved in an invalid format refuses every call until it is saved again.
  • Every change shows the before and after and requires a note; the server recalculates the difference, refuses empty changes and records everything in the audit log.
  • The AI rules version used is recorded on every agent run and every chat message.
Through the signed-in area API Routes used by the UI, with a browser session: read the policy, change the ceiling and change the AI rules, always with the revision note.
GET /api/platform/org-policy            (policy, rules, history and options)
PUT /api/platform/org-policy            { policy, note }
PUT /api/platform/org-policy/rules      { content, note }

What it does not do

  • Only the organization owner, with membership across the whole organization, can change the policy and the rules.
  • AI rules do not apply to library prompt runs or to flows.
  • With sending outside Brazil turned off, the platform keys for Anthropic and OpenAI are blocked, because their region is unknown.
  • The quota counts approved calls in the month; the monetary ceiling lives in the organization budget.

Platform governance

Reviewable governance: Git, AI with approval and a continuous trail

Policies and pipelines are exported as deterministic JSON files, with a hash, to live in the team's repository. Importing back compares file by file and shows the plan; applying saves new versions, which only take effect when someone activates them. Saving a pipeline goes through the workspace policy: denied does not save, and "needs approval" saves without putting it into effect.

An admin describes the rule in one sentence and AI proposes the policy in the platform format. The proposal goes through the same validation as hand-written rules, comes with a replay of the last 30 days of decisions (what would change from allowed to denied, and the reverse) and stays pending until a person approves it.

How it works

  • Rules by tag: the policy applies only to services with the catalog tags, read from the graph and never from whoever requests the decision.
  • Analysis of the failed CI stage: likely cause, category and suggestion, with the log lines that support the answer.
  • Discovered agents: API keys that call models outside the platform agents, with checks on expiry, scope, budget and human review; agents, prompts and models become graph entities.
  • Ready-made MCP server files for Claude Code, Cursor and Visual Studio Code, with the key read from an environment variable.
  • Technical compliance package: products, AI providers actually used, retention and audit chain integrity.
  • Streaming audit: every workspace event goes out through the signed webhooks subscribed to audit.*, with retries.

Example use case

The platform team keeps policies in the repository and reviews changes in the pull request. After the merge, the admin pastes the files into the UI, checks the plan and applies it. To block deploys of services tagged pci outside business hours, the admin asks AI for the rule, looks at how many decisions from the last month would change and approves. The company SIEM receives every audit event through the webhook.

What it does not do

  • AI proposes and analyzes; nothing it writes takes effect or runs without a person.
  • A new pipeline is created in the UI, linked to the repository; only new versions come in through Git.
  • The compliance package is not a contract or a certification.
  • Discovery only sees traffic that goes through the AIUBY Gateway.

MCP server

Your coding assistant queries engineering data without changing anything

A Model Context Protocol server, over Streamable HTTP transport, that gives clients such as Claude Code and Cursor the same reads as API v1: graph services and entities, security findings and scans, SLOs, incidents, runbooks, artifacts, feature flags, events, delivery indicators with AI cost, and published skills.

Authentication uses the same API key as v1, with the scope to read engineering data or, for skills only, the scope to download published skills. Every tool is marked read-only, and each call goes into the organization audit log, with the key as the actor.

How it works

  • Four generic tools: describe the types and filters, list a type, read a resource and run a structured graph query.
  • The graph query is by intent from a closed catalog, with no model and no cost, and every row cites its evidence.
  • Output matches API v1: fields from a closed list, repository and alert text sanitized and free of secrets, treated as data and never as instructions.
  • An unknown filter is an error, not ignored; pagination uses an opaque cursor.
  • API v1 limits, counted per request: 120 per minute per key and 300 per minute per workspace.
  • The CLI prints the configuration block ready for Claude Code, Cursor or a generic client.
Client configuration (.mcp.json) Project file for Claude Code, which expands the environment variable with the key; the key never goes into a versioned file.
{
  "mcpServers": {
    "aiuby": {
      "type": "http",
      "url": "https://aiuby.com/api/mcp",
      "headers": { "Authorization": "Bearer ${AIUBY_TOKEN}" }
    }
  }
}

What it does not do

  • There are no write tools: nothing the server does changes state.
  • Natural-language questions with a model stay in the UI only.
  • There is no OAuth or session: the API key goes in the header of every request.
  • Incident timeline, notes and postmortem, finding exception justifications and flag rules are left out of the output.

Platform assistant

Usage questions answered on screen, from the documentation

The Assistant is the side drawer available on every screen of the signed-in area. It knows which screen the person is on and answers usage questions with AIUBY documentation as its fixed source: the product catalog, the section for each feature and the public documentation pages.

When the person has a resource open, such as an agent run, a flow run or an agent, the Assistant reads its data through that resource's own service and with the permissions of whoever is asking. So the question "why did this run fail?" is answered with that run's output and trace.

How it works

  • Semantic search over the documentation, with embeddings through the Gateway; when embeddings are unavailable, it falls back to keyword search.
  • The index is rebuilt every hour, only for what changed, and whatever left the documentation leaves the index.
  • What the person cannot see stays out: the resource service responds as if it did not exist and nothing is read.
  • Resource data comes in as data, escaped, and is not stored in the conversation.
  • The call goes through the Gateway with the workspace and organization policy, and the cost of the question belongs to whoever asks it.

Example use case

A team member opens an agent run that ended with an error and asks the Assistant what happened. The answer cites the failed step and the tool called, taken from the run itself, and points to the documentation on how to raise the agent budget. Next, they ask how to turn on deployment freezes, and the answer comes from that feature's section.

What it does not do

  • Read-only: the Assistant takes no action, approves nothing and changes nothing.
  • It reads data from agent runs, flow runs and agents; on other screens, it knows which screen is open, not its data.
  • It answers about AIUBY from the public documentation; it does not query external systems.

For developers

API, CLI and MCP on the same key

One scoped API key works for the API, the public CLI and the MCP server that coding assistants read. The snippets below come from the documentation.

Public CLI API, CLI & keys
aiuby login       # paste the key; it does not appear on screen
aiuby whoami

aiuby init fastapi-http minha-api   # copies a starter template
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
Models API Models & Gateway
curl -sS -X POST "https://aiuby.com/api/gateway/v1/chat/completions" \
  -H "Authorization: Bearer $AIUBY_TOKEN" -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-5-5",
    "max_tokens": 512,
    "messages": [
      {"role": "system", "content": "Answer in Portuguese, in at most three sentences."},
      {"role": "user", "content": "What is an audit trail?"}
    ]
  }'
MCP server, read only MCP server
{
  "mcpServers": {
    "aiuby": {
      "type": "http",
      "url": "https://aiuby.com/api/mcp",
      "headers": { "Authorization": "Bearer ${AIUBY_TOKEN}" }
    }
  }
}
Read the docs

Integrations

Only what exists in the code

Each integration inherits the status of the feature that uses it. No inflated counts, and no logos of tools the platform does not call.

  • Google Cloud RunRuns Compute runtime applications on CPU and GPU.Software Delivery
  • Public CLIDeploy, view logs, write secrets and check billing from the terminal (@aiuby-ia/cli).Software Delivery
  • GitHubA push to the branch triggers the pipeline, through a webhook with a verified signature.Software Delivery, Security Testing, Code Automation, Developer Portal, Engineering Intelligence, Resilience Testing, Test Automation
  • Cloud MonitoringError rate and p95 latency of the candidate revision at each rollout step.Software Delivery
  • KubernetesAn agent in the customer cluster, with minimal RBAC in the environment namespace.Software Delivery, Resilience Testing
  • OpenTofuManaged plan and apply, with state in the customer's S3 or GCS.Software Delivery
  • AWS and Google CloudOIDC federated identity for infrastructure runs, with no long-lived keys.Software Delivery
  • TerraformReads .tf files and the plan JSON generated in the customer's CI.Software Delivery, Resilience Testing
  • Postgres and MySQLAnalysis of SQL migration files, without connecting to the database.Software Delivery
  • Docker and npmPer-workspace repositories on Google Artifact Registry, in São Paulo.Software Delivery
  • cosignImage signatures verified against the workspace public key.Software Delivery
  • GitHub status checksPipeline results published on the commit, which branch protection can require.Software Delivery
  • Jira and ServiceNowAn approved change ticket as a condition for deployment approval.Software Delivery
  • SlackDeployment and CI events through webhooks, in Slack format.Software Delivery
  • AnsiblePlaybooks run by the self-hosted runner, with --check --diff by default.Software Delivery
  • Flyway and LiquibaseSQL changelogs applied by the runner after approval by hash.Software Delivery
  • OSV and TrivyDependency vulnerabilities and licenses.Security Testing
  • gitleaksSecrets left behind in the repository.Security Testing
  • OpenGrepThe SAST engine, with rules written by AIUBY.Security Testing
  • CycloneDX and SPDXSBOM export formats.Security Testing
  • Google Cloud Run JobsWhere the isolated runner executes each analysis.Security Testing, AI & API Security
  • EPSS and KEVFIRST exploit probability and the CISA known exploited catalog, on the finding and in the gate.Security Testing
  • SARIFResults from any code scanner imported into the same triage.Security Testing
  • ZAPPassive web application scanning against a target with proven ownership.Security Testing
  • deps.dev and OSVDeprecated dependencies and new advisories for SBOM components.Security Testing
  • JiraAn issue opened from a finding through a webhook in the Jira Cloud automation format.Security Testing
  • API v1 and CLIRead findings, scans and SBOMs with a scoped key.Security Testing, Developer Portal, Engineering Intelligence
  • MCP serverFindings, scans and SBOMs for coding assistants, read-only.Security Testing, Developer Portal, Engineering Intelligence, Feature Management
  • Model gatewayWhere the policy is enforced on every platform call.AI & API Security, Code Automation, Engineering Intelligence, Test Automation
  • MCP toolsArguments of every call checked against the declared schema.AI & API Security, Incident Management
  • Knowledge and agentsDocument chunks and tool results scanned before they return to the model.AI & API Security
  • Chrome extensionChecks text sent to the listed AI sites.AI & API Security
  • Perimeter proxyInventory by destination, on the customer network, without opening the content.AI & API Security
  • OpenAPI and SwaggerSpecs read from GitHub repositories or uploaded by the team.AI & API Security
  • nginx, Envoy and KongGateway access logs sent by a lightweight collector, metadata only.AI & API Security
  • PostmanCollections as a source of AI test targets.AI & API Security
  • SIEM through webhooksSigned MCP firewall events, with retries.AI & API Security
  • Organization AI policyA ceiling on models, providers, masking and tools above the workspaces.AI & API Security
  • Mercado Pago (Pix)Loads the prepaid balance.Cost Management
  • Central Bank of Brazil PTAXReference rate for the price in reais in automatic mode.Cost Management
  • AWS Cost ExplorerReads AWS billing, read-only.Cost Management
  • Google Cloud (BigQuery)Reads the GCP billing export.Cost Management
  • CSV in FOCUS formatImports billing from any provider.Cost Management
  • OpenAI and AnthropicOrganization cost through each provider's cost API, with the admin key stored encrypted.Cost Management
  • GitHub CopilotSeats and activity through the admin API.Cost Management
  • Claude CodeUsers and usage report through the Anthropic admin API.Cost Management
  • CursorMembers, daily usage and on-demand spend through the team Admin API.Cost Management
  • aiuby CLICompute balance, cap and statement from the terminal.Cost Management
  • node22, python312 and go126 imagesIsolated runner environments where the patch is applied and the repository tests run.Code Automation
  • Policies and kill switchThe code.pull_request.create policy and the organization kill switch apply to plans, patches, dispatches and PRs.Code Automation
  • API v1Reads the loop state of each ticket with a key scoped to engineering:read.Code Automation, Feature Management
  • Customer CIYour CI sends the commit code index and its own checks, with links to logs, screenshots, traces and review environments.Code Automation
  • Solutions catalogCode Reviewer and Change Verifier install as experts over the documentation Cortex indexes.Code Automation
  • Delivery graphServices, systems, APIs, owners and dependencies are entities in the platform graph.Developer Portal, Engineering Intelligence
  • Scanners, SLOs and pipelinesOpen findings, SLOs and the latest run of each pipeline are the rule sources.Developer Portal
  • Code AutomationThe approved proposal becomes a draft pull request through the same writer, with the same guardrails.Developer Portal, Feature Management, Test Automation
  • Pipelines and ComputeThe blueprint points to the pipeline that brings the environment up and uses the Compute rate table to forecast the monthly cost.Developer Portal
  • HTTPS pluginsAn endpoint of yours receives the entity summary and returns text cards shown next to the service.Developer Portal
  • AIUBY Compute, Kubernetes and IncidentsDeployments, Kubernetes delivery rollouts and incidents per service, the sources of the DORA indicators.Engineering Intelligence
  • AIUBY CIThe first CI run of a commit marks the start of lead time until that commit is deployed.Engineering Intelligence
  • Jira, Linear and other ticketing toolsWork items sent by your script to API v1, with a key scoped to engineering:ingest. AIUBY does not pull from the tools.Engineering Intelligence
  • GitHub Copilot, Claude Code and CursorSeats and aggregated daily usage, through each vendor's official admin APIs.Engineering Intelligence
  • Prometheus AlertmanagerAlert webhook.Incident Management
  • SentryIssue integration webhook.Incident Management
  • Generic webhookAny tool that sends JSON.Incident Management
  • EmailOn-call page to the address the person confirmed.Incident Management
  • WhatsApp (Voxentra Flow)On-call page through the Flow registered in the workspace, with signed delivery.Incident Management
  • n8nA runbook step that triggers a workflow registered in the workspace.Incident Management
  • Slack (your team's app)The /incidente command and the incident channel scribe, with signature verification.Incident Management
  • Jira, ServiceNow and PagerDutyA ticket opened from the incident, with the customer credential encrypted.Incident Management
  • PrometheusSLO health source: a scheduled query of the good and total series.Incident Management
  • Event webhooksIncident open, update and resolve, and on-call pages, as signed events.Incident Management
  • API v1 and MCP serverRead SLOs, incidents and runbooks with an API key.Incident Management
  • Dockerfile and docker composeUnpinned images, missing healthcheck, restart policy and memory limit.Resilience Testing
  • aiuby CLI in CIThe check command returns an exit code the pipeline uses as a gate.Resilience Testing
  • Delivery pull agent (Kubernetes)Applies and rolls back chaos faults and generates load inside your cluster.Resilience Testing
  • GitHub ActionsThe aiuby-load-test action triggers load scenarios and uses the verdict as the job gate.Resilience Testing, Test Automation
  • Anthropic, OpenAI and Google CloudModel providers connected to the gateway.AI Engineering
  • Your company's n8nFlows call automations with a signed callback.AI Engineering
  • MCP serversYour company's tools, reviewed before use.AI Engineering
  • PostgresRead-only queries against a company database.AI Engineering
  • Claude Code and CursorCoding agents download published skills and verify the hash.AI Engineering
  • MCP clientsRead engineering data and published skills through the MCP server, with an API key.AI Engineering
  • API and webhooksChat, knowledge search and runs of agents, prompts and flows over the API.AI Engineering
  • OpenTelemetry (OTLP HTTP JSON)Agents running outside AIUBY send spans, redacted on ingestion.AI Engineering
  • OpenFeatureProviders for @openfeature/server-sdk and @openfeature/web-sdk: your code queries flags through the open standard.Feature Management
  • JS/TS SDK @aiuby-ia/flagsZero-dependency client for browsers and Node 18+, with local evaluation from the snapshot, caching and offline mode.Feature Management
  • Prompt libraryAn AI Config references a workspace prompt and its published version.Feature Management
  • Data connectorWarehouse analysis queries your Postgres-compatible database, read-only and only on allowed tables.Feature Management, Test Automation
  • PoliciesThe flag.publish policy is evaluated on every publish.Feature Management, Test Automation
  • PlaywrightRuns the repository @playwright/test suite, with chromium, firefox and webkit projects and JSON and JUnit reports.Test Automation
  • PipelinesThe browser_tests step runs the suite from the same repository and commit as the pipeline and fails the job if any test fails.Test Automation
  • CLI and API v1aiuby tests run and the run endpoints, with a key scoped to tests:run, for use in any CI.Test Automation
  • Jira CloudAn issue opened by an admin from a failed run, with the steps and the link.Test Automation

Architecture

The eight layers, and how each depends on the others

Pick a layer to see its role, which layers it works with, the controls it applies and a sample operation.

01 · Identity and isolation

Organizations, workspaces and roles.

In production today

Every organization and every workspace isolated in the database, with row-level security in Postgres.

Controls

  • Organizations and workspaces isolated in the database, with row-level security
  • Owner, admin and member roles per workspace
  • API credentials with scope, expiry and revocation

Sample operation ILLUSTRATIVE

  1. credential with the agents:run scope
  2. only the published agent version runs
  3. the run stays in the credential workspace
Credentials in AI & API Security

02 · AI Gateway

A single entry point to the models, with cost and policy applied before the call.

In production today

Anthropic, OpenAI and Google Cloud (Gemini and open models such as gpt-oss, DeepSeek and GLM) with the platform key, plus Google Gemini, AWS Bedrock, Azure OpenAI and OpenAI API compatible services through an organization connection, with a fallback route, a budget per workspace and cost recorded per request.

Controls

  • Policy applied before the call leaves for the provider
  • Fallback route between providers
  • Model rules by role, team and person

Sample operation ILLUSTRATIVE

  1. call received
  2. workspace policy applied
  3. enabled model responds
  4. cost recorded
Usage calculator

03 · Enterprise chat

Conversations over the company knowledge base.

In production today

Every answer cites the document it came from.

Controls

  • Searches only what the person is allowed to see
  • Answers with the source document
  • With no source, the answer says nothing was found

Sample operation ILLUSTRATIVE

  1. question about a policy
  2. passage found in the knowledge base
  3. answer cites the document
Knowledge bases (AI Engineering)

04 · Agent runtime

Versions, tools, approvals and run limits.

In production today

Immutable versions, human approval for any side effect, trace and cost per run.

Controls

  • Immutable versions; only the published one runs
  • Tools enabled one by one
  • Human approval before any tool with side effects

Sample operation ILLUSTRATIVE

  1. agent answers with a source
  2. proposes an action
  3. waits for approval
  4. trace and cost stored
Agent Management (AI Engineering)

05 · Knowledge engine

Ingestion, permission-aware retrieval and source tracking.

In production today

Text, Markdown, PDF and CSV spreadsheets; hybrid search; permissions and versions per document.

Controls

  • Permission and version per document
  • Keyword and semantic search
  • Scanned PDFs are not read (no OCR)

Sample operation ILLUSTRATIVE

  1. document uploaded
  2. text indexed with permissions
  3. passage cited in an answer
Knowledge bases (AI Engineering)

06 · Automations and integrations

Connections to company systems, always through an approval gate.

In production today

n8n flows with a signed callback and MCP servers with reviewed tools.

Controls

  • n8n workflows with a signed callback
  • MCP servers with reviewed tools
  • Every action goes through the approval gate

Sample operation ILLUSTRATIVE

  1. agent requests a workflow
  2. a person approves
  3. the n8n workflow is triggered
  4. signed callback confirms
Workflows in AI Engineering

07 · Governance

Policies per workspace, audit and retention.

In production today

Sensitive data, limits and tool blocking; hash-chained audit, exportable as CSV and JSON.

Controls

  • Sensitive data: blocking or masking by category
  • Per-minute and concurrency limits; blocked tools
  • Hash-chained audit with configurable retention

Sample operation ILLUSTRATIVE

  1. call containing a CPF (Brazilian tax ID)
  2. policy blocks it before the model
  3. event enters the chained trail
AI & API Security

08 · Cost and tracing

What each use cost and what happened in each run.

In production today

Cost per request and per agent run, with a trace of every step. Admins see p50 and p95 latency, errors and the fallback route of each call, without the content. With AIUBY Models, usage is billed in BRL.

Controls

  • Cost per request and per agent run
  • Budget per person, credential, model and project, with alerts
  • Latency, errors and fallback route without the call content

Sample operation ILLUSTRATIVE

  1. run finishes
  2. cost added to the budget
  3. alert near the limit
Models & Gateway (AI Engineering)

Where it falls short

Limits we would rather state up front

  • The graph only knows what has been connected. A repository outside GitHub or a service with no registered owner is left out, and the answer says so instead of guessing.
  • The platform is hosted by AIUBY. Only the runner and the delivery agent run on your side; there is no installable version of the whole platform.
  • A policy enforced on the call only protects what goes through the platform. Direct AI use in the browser is partly visible through the extension; the proxy only sees the destination.
  • Hash-chained audit only proves tampering if someone stored a hash outside the platform (the last one noted or a previous export). Without that anchor, whoever administers the database can recompute the chain.

How to buy

You create the account yourself

If you prefer, AIUBY sets it up and works alongside your team.

  1. Create your account

    Sign-up creates your company's organization and first workspace on the platform, hosted by AIUBY, with isolation per organization.

  2. Add products

    Choose the products and the tier under Products. Adding is free: the monthly fee starts the first time you use each product.

  3. Add credit and go

    Everything is prepaid: top up your balance and use it. Documents, agents, solutions, policies and flows stay with your team, with cost and audit in plain view.

  4. Count on the team

    If you prefer, AIUBY builds the solution for your area and follows up on adjustments. Engineering services are always delivered with the team.

Prices are on the Pricing page. For an order of magnitude of model costs, the usage calculator estimates what the provider charges for tokens. Already a customer? Log in to the customer area.

See all products