Skip to content

Production AI with versions, tests and cost

AI Engineering · Agents, LLMOps and model gateway

Agents, flows, knowledge bases, evals, prompts, skills and model access live in one place, each with a version, permissions and cost measured per call. Governance sets how far each agent can go, and the trace shows what every run did.

The problem

What this product solves

When every team wires up AI its own way, nobody knows which prompt is live, which document the agent read or what it cost.

The first serious incident, a wrong answer or an action nobody authorized, reveals there was no version, no test and no record.

And as agents multiply, there is no single place to say what each one may do on its own, or to switch off the one that went off script.

updated

Who uses it, and for what

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

  • Customer service team at an insurerAnswer from internal documents and cite the source of every answer.Knowledge bases
  • Product team building with AIShip only the prompt or agent version that passed the eval.Evals
  • Platform and security teamSet the autonomy level and network access of each agent, and shut an agent down instantly.Agent governance

Features

What the product does

Self-service: add it from your account.

  • Agent Management

    Versioned agents with allowed tools, human approval and simulated writes.

  • Specialist & worker agents

    Read-only specialist agents and propose-only workers, with policy, limits and human review.

  • Agent governance

    Per-agent autonomy (observe, propose, execute with approval, execute within policy with budgets), trust tiers with four-eyes review, per-agent network policy and kill switch per agent and per organization, with every decision in the trace.

  • Agent operations

    Human annotation of runs with your own taxonomy, real runs turned into eval cases and JSONL datasets with personal data masked, sessions with cost per ticket, environments with promotion and autonomy per environment and per team, a CycloneDX AI-BOM, OpenTelemetry ingestion from external agents, evals through the v1 API and MCP, code search with per-repository access and flows that call flows.

  • Workflows

    Workflows with steps, conditions, approvals and schedules.

  • Evals

    Test cases, model-graded judging, publish gates and version comparison.

  • Prompt & config registry

    Versioned prompts, publishing and comparison.

  • Knowledge bases

    Search with sources and per-document permissions.

  • Models & Gateway

    Model API with providers, routing and per-role model access.

  • Skills registry

    Versioned skills catalog for coding agents: manifest with declared permissions, SKILL.md with sha256, publishing only after review by another person, download via API v1 and MCP. The platform never runs skills.

  • Execution traces

    Per-run steps with cost and latency, sessions by free-form key with summed cost, OpenTelemetry span intake (OTLP/HTTP JSON) from external agents with redaction on entry, a CycloneDX AI-BOM and the Assistant reading the open run.

Agent Management and Workflows: in detail

  • Immutable versions of every agent
  • Human approval before any agent tool with side effects
  • Trace and cost for every run
  • Integration with n8n flows, with a signed callback
  • MCP client with tools reviewed before use
  • Flows: processes built from blocks, with human approval, scheduling and API runs
  • Data tools: PTAX exchange rates from the Central Bank of Brazil and read-only queries to a company Postgres

Knowledge bases: in detail

  • Text, Markdown and PDF documents, plus CSV spreadsheets
  • Hybrid search, by keyword and by meaning
  • Per-document permissions
  • Versions of every document
  • Chat answers that cite the source

Evals: in detail

  • Evaluation suites per agent
  • Publish gate: a version is published only if it passes the suite
  • Model-graded scores, with criteria written in plain language
  • Comparison between versions

Models & Gateway: in detail

  • Prepaid balance in BRL, topped up via Pix
  • Price that tracks the official dollar rate (PTAX from the Central Bank of Brazil), with every adjustment in the audit log
  • BRL amounts in chat, agents, usage, budgets and the audit log

What it does not do

  • An agent tool with side effects never runs without a person approving it.
  • No access to a production shell.
  • Document content is treated as data, never as instructions.
  • No OCR for PDFs: a document scanned as an image is not read.
  • An evaluation result holds for the tested set, not as a general guarantee.
  • The platform does not issue invoices (nota fiscal) automatically.
  • Models run on the providers' servers; processing may happen outside Brazil.

Lifecycle

From prompt to production

The lifecycle of an agent on the platform. Each stage carries the status of the feature that runs it.

  1. Versioned prompt

    The prompt gets a new version with every change, with publishing and comparison between versions.

  2. Knowledge

    The documents the agent can consult, with per-document permissions and the source cited in the answer.

  3. Agent version

    Instructions, model, tools granted one by one, and caps on steps and cost.

  4. Evaluation

    Test cases scored by a model; a version that got worse does not publish.

  5. Model gateway

    The call goes out only to a model allowed in the workspace, with cost measured.

  6. Run with approval

    A tool with side effects waits for a person to decide; the steps keep their cost and latency.

  7. Tracing

    Sessions with total cost and spans from external agents received via OpenTelemetry, redacted on ingestion.

What an agent version defines Example with fictitious values. Maximum cap: 25 steps and US$ 5 per run; cost is expressed in millionths of a dollar.
{
  "instructions": "Answer reimbursement questions citing the internal policy. To open a ticket, ask for approval.",
  "model": "model-allowed-in-the-workspace",
  "tools": [
    "knowledge_search",
    "simulated_ticket_create"
  ],
  "maxSteps": 8,
  "maxCostMicros": 500000
}

How it works

From start to audit record

  1. Models

    The workspace enables models and fallback routes. Every call goes through the Gateway, with budget and policy.

  2. Knowledge

    Documents in the workspace knowledge base, with versions and per-document permissions.

  3. Prompt, agent or flow

    A new version on every change, with the tools enabled for it and caps on steps and cost.

  4. Eval

    Test cases scored by a model. A worse version does not ship.

  5. Run

    An agent tool with side effects waits for approval. In a flow, approval is the step you place before the connector.

  6. Record

    Each step keeps its cost and latency, a session groups runs and spans from external agents, and the approver's decision goes into the audit trail.

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.

Agent Management

Versioned agents that stop before touching another system

An agent is a set of instructions, a model and a closed list of tools, saved as a version. Every change creates a new version; the published one is what runs from the UI, the API and inside flows.

A read-only tool runs directly. A tool with side effects (triggering an automation, writing to a system over MCP) pauses the run and shows the exact text of what it will do. A person with permission approves or rejects it in the customer area.

How it works

  • A version holds instructions, model, tools allowed one by one, a step cap and a cost cap per run.
  • Tools: knowledge base search, the company's n8n automations, reviewed MCP server tools, read-only queries to a Postgres database, and delegating a subtask to another agent, up to two levels deep and with the remaining budget.
  • Human approval with a 24-hour deadline; a tool blocked by the workspace policy is refused even after approval.
  • A tool only runs if it is in the agent version and the person who triggered the run has its permission; the approver needs the approver permission.
  • Simulated write: a test tool that goes through the approval cycle without touching any system.
  • API execution with a key scoped to "Run agents", a required idempotency key and a signed completion notice.
Through the API Starts the published version of the agent (the 202 response carries the identifier) and checks the run.
curl -sS -X POST "https://aiuby.com/api/platform/agents/$AGENTE_ID/runs" \
  -H "Authorization: Bearer $AIUBY_TOKEN" -H "Content-Type: application/json" \
  -d '{"input":"Order 4471: check and forward","idempotencyKey":"pedido-4471"}'

curl -sS "https://aiuby.com/api/platform/agents/runs/$EXECUCAO_ID" \
  -H "Authorization: Bearer $AIUBY_TOKEN"

What it does not do

  • No API key can approve: the decision always belongs to a person, in the UI.
  • Agents have no access to a production shell.
  • A key can only check the runs it started itself, with up to 20 open runs at a time.
  • Each run triggers at most 3 automations and makes at most 3 writes over MCP.

Specialist & worker agents

Ready-made agents that query and propose, without applying anything

A catalog of agents maintained by AIUBY, in two roles. Specialists only read: they answer questions about cost, dependency security, incidents, tests and deliveries, citing the evidence for every claim. Workers only propose: they put together a patch, review comments or a new dependency version, and stop there.

No catalog agent executes a change. A worker's proposal becomes a decision for another person with approval permission, never for whoever triggered the run.

How it works

  • Eight read-only specialists, each with a closed list of tools and sources it can query.
  • Six proposal workers; the output is an artifact for review, not an applied change.
  • Caps on steps, cost and time per run, defined in each agent's policy.
  • Specialist answers come with cited evidence; without evidence, the agent says it does not know.
  • The decision on the proposal belongs to another manager: whoever ran the worker cannot approve its own result.
  • Each run's AI cost goes through the Gateway, with the same workspace model and budget rules.

Example use case

Someone on the platform team asks the dependency specialist which services use a library with a known flaw. The agent reads the findings and the delivery graph and answers with the list and the source of each item. She then triggers the dependency update worker for one of the services: it returns the new version proposal, and another person on the team decides whether it goes to the repository.

What it does not do

  • No catalog agent applies changes: specialists only read and workers only propose.
  • Three workers (feature flag cleanup, code coverage and infrastructure as code fixes) are unavailable because the input they depend on is missing.
  • Each catalog agent's level is fixed in its definition: the organization cannot turn a specialist into an executor.

Agent governance

You decide how far each agent goes, and switch it off when needed

Each agent gets an autonomy level: observe (tools with side effects are denied), propose (the action becomes a proposal recorded in the trail), execute with approval (the default: it waits for a person) or execute within policy. The last one skips approval only for tools the admin marked as low risk and only while there is action budget left per run and per day; beyond that, it asks for approval again.

Alongside come the agent trust level, the per-agent network policy and the kill switch per agent and per organization. Every decision on a tool call is recorded in the run trail, with level, trust, tool, decision, reason and destinations, and every rule change goes into the audit log.

How it works

  • Four autonomy levels per agent; "execute within policy" is off by default, and the admin must turn it on in the organization rules before choosing that level.
  • Trust levels: managed (AIUBY catalog), verified (reviewed by the organization) and unreviewed (imported). An imported agent only becomes verified with four eyes: someone requests the review and another admin verifies it.
  • The organization defines which workspaces each trust level runs in; by default, unreviewed agents run in none.
  • Per-agent network policy: organization default, no destinations or an allowlist, with hosts and MCP servers. The check happens before execution, and the block is recorded.
  • Kill switch: turning it on cancels running executions and pending approvals and prevents new runs, in the service, the engine and the database.
  • Automatic approval shows up in the run identified as a governance decision, not as a person's decision.
Through the signed-in area API Routes used by the UI, with a browser session: adjust an agent, switch it off, switch it back on and trigger the organization kill switch.
PUT /api/platform/agent-governance/agents/{ref}
{ autonomy?, networkMode?, networkAllowlist?, lowRiskTools?, maxAutoPerRun?, maxAutoPerDay?, trustTier?: 'unreviewed' }

POST /api/platform/agent-governance/agents/{ref}/kill     { reason? }
DELETE /api/platform/agent-governance/agents/{ref}/kill
POST /api/platform/agent-governance/kill

What it does not do

  • Governance only restricts: it never expands what the agent version and the triggering person's permissions allow.
  • An unreviewed imported agent cannot use tools with side effects, at any autonomy level.
  • A tool that writes on behalf of the approver can never be marked as low risk.
  • The default budget for actions without approval is zero: unless the admin sets one, everything still asks for approval.

Agent operations

Human-reviewed runs become cases, datasets and rules

Reviewers mark each run as correct, wrong or uncertain, with labels from the workspace taxonomy and the reason. A completed run becomes an eval case in one click, with credentials and personal data masked, and the annotated set exports as a JSONL dataset. The reason can become a document in Knowledge, the agents' shared memory.

The same agent runs in environments with pinned versions and promotion (only a version approved by the suite), and autonomy can be lower in an environment or for a team: the most restrictive always wins. External agents send OpenTelemetry spans, which come in redacted and join runs from the same session with the cost added up.

How it works

  • Per-run annotation, with its own taxonomy and feedback memory in Knowledge.
  • A real run becomes an eval case; JSONL dataset with personal data masked.
  • Sessions and cost per ticket, combining internal runs and external spans.
  • Environments with promotion, and autonomy per environment and per team.
  • AI-BOM in CycloneDX 1.6, evals through API v1 and three MCP tools with the agents:eval key, and code search with per-repository access.
  • A flow that calls another flow, once or as a matrix (one run per list item, up to 10 in parallel), with limited depth and a failure strategy per stage.
External agent sending spans, and the suite in CI Any OpenTelemetry SDK with the OTLP HTTP JSON exporter works; the key has the agents:trace scope.
OTEL_EXPORTER_OTLP_PROTOCOL=http/json
OTEL_EXPORTER_OTLP_ENDPOINT=https://aiuby.com/api/v1/otel
OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer $AIUBY_TOKEN"

What it does not do

  • Autonomy per environment or per team only restricts: it never expands the agent's own.
  • Code search covers up to 400 code files per repository, from the default branch, and an API key only finds unrestricted repositories.
  • Span attributes with a credential name are dropped on ingest; the rest goes through personal data masking.

Workflows

Multi-step processes, with approval wherever you put it

A flow links stages in a diagram: agents, knowledge search, connectors, conditions and approvals. You build it on the canvas or through a form, test the draft and publish; publishing validates the diagram and saves a version that no longer changes.

A flow starts from a person, a schedule, the API or another flow. Human approval is a stage in the diagram: a connector after it waits for the decision; a connector without that stage before it runs directly, including when the flow is triggered by a schedule.

How it works

  • Stages: start, agent, knowledge base, connector, human approval, condition, join, run another flow and end; 2 to 5 agents can run in parallel.
  • An agent inside a flow runs its published version through the same path as any other run: Gateway, budget, limits, sensitive data and approval for its tools.
  • A connector only calls automations registered in the workspace n8n, with the parameters defined in the flow and one trigger per step.
  • Schedules by interval (15 minutes to 7 days), daily or weekly, running on behalf of whoever scheduled them; each stage chooses whether a failure ends the run, continues as output or retries up to 3 times.
  • Publishing refuses diagrams with cycles, unreachable stages, conditions without both branches, agents without a published version or unregistered automations, and the screen marks what to fix.
  • Each run keeps its steps, and creating, publishing, scheduling, starting, approving and rejecting go into the audit log.
Through the API Starts a published flow that accepts API triggers and checks the run.
curl -sS -X POST "https://aiuby.com/api/platform/flows/$FLUXO_ID/runs" \
  -H "Authorization: Bearer $AIUBY_TOKEN" -H "Content-Type: application/json" \
  -d '{"input":"Order 4471: check and forward","idempotencyKey":"pedido-4471"}'

curl -sS "https://aiuby.com/api/platform/flows/runs/$EXECUCAO_ID" -H "Authorization: Bearer $AIUBY_TOKEN"

What it does not do

  • A connector without an approval stage before it runs without anyone approving, including on a schedule: the stage is the designer's choice.
  • A flow without a published API trigger returns 409 to a key; input is limited to 20,000 characters.
  • A run has at most 60 steps and 25 hours; a pending approval expires in 24 hours.
  • Schedules are always in UTC, and missed times do not pile up.

Evals

A version that got worse never reaches production

Each agent has a suite of test cases. A case states the input and what is expected: text that must appear, tools the agent should use, tools it must not use and a rubric, which is the criterion written by the team.

The suite runs against an agent version, and a model acts as the judge, scoring each case by the rubric. Without a passing eval, the version does not publish. Comparing two versions shows, case by case, what regressed.

How it works

  • Cases with expected text, expected tools, forbidden tools and a rubric.
  • Model as judge: the score follows the criterion the team wrote, not a generic one.
  • Publishing gate: a version only publishes with a passing eval.
  • Version comparison with regressions highlighted, next to the differences in instructions, model and tools.
  • Ready-made solutions ship with starter cases, including prompt injection attempt cases.

Example use case

The support team changes the instructions of the agent that answers return questions. Before publishing, they run the suite: almost every case passes, and one fails because the new version stopped citing the exchange policy. The comparison shows the case that regressed, the team adjusts the instructions, runs it again and only then does the version publish.

What it does not do

  • It evaluates platform agents: it does not accept agents running outside it.
  • Each agent has up to 20 cases.
  • It does not roll back a published version on its own: rolling back means publishing another version that passes the gate.

Prompt & config registry

Company-approved text, with versions and a form

The library stores workspace prompts as text with typed variables: text, long text, choice, number and date. Each prompt goes through draft, test and publish, and each published version no longer changes.

Users do not write prompts: they fill in the form generated from the variables, in the UI, inside chat or through the API. The run goes through the Gateway, with allowed model, budget, limits and sensitive data policy, and the result comes with its cost.

How it works

  • Typed variables, description, suggested model and tags on each version.
  • Line-by-line version comparison, with changes to description, model, tags and variables.
  • Form validated in the UI and again in the API: required fields, options from the list, numbers, real dates, and unknown fields refused.
  • Those who configure agents can edit; members only use the published version of an active prompt.
  • Through the API, with the "Run prompts" scope: read the form and run with an idempotency key; repeating the same key returns the same run, with no new charge.
  • Filled-in values are not stored; the output is.
Through the API Reads the form of the published version and runs the prompt with the variable values.
curl -sS "https://aiuby.com/api/platform/prompts/$PROMPT_ID" -H "Authorization: Bearer $AIUBY_TOKEN"

curl -sS -X POST "https://aiuby.com/api/platform/prompts/$PROMPT_ID/runs" \
  -H "Authorization: Bearer $AIUBY_TOKEN" -H "Content-Type: application/json" \
  -d '{"values":{"cliente":"<customer name>","tom":"consultative"},"idempotencyKey":"proposta-001"}'

What it does not do

  • Runs are synchronous: there is no completion notice for prompts.
  • Prompts are not shared across workspaces.
  • An API key only runs the published version; drafts are tested in the UI.

Knowledge bases

Answers with the passage and the document they came from

Each workspace has document bases, with versions per document. Search returns the passage, the title, the base and the version it came from, and that is how chat and agents answer while citing the source.

Permissions are per document. A document restricted to certain people only appears for them, and is left out of results for searches made with an API key. Document content is treated as data, never as an instruction to the agent.

How it works

  • Formats: text and Markdown (up to 5 MB), PDF with text (up to 20 MB) and CSV (up to 2 MB, 20,000 rows and 60 columns).
  • Search from the UI, from agents, from the knowledge stage in flows and through the API, with the "Search Knowledge" scope.
  • Each result carries passage, document title, base, version, position and score.
  • Upload through the API with the "Upload documents to Knowledge" scope: list the bases and upload documents or new versions.
  • Queries of up to 2,000 characters and up to 20 results per search.
Through the API Searches the workspace documents; each result comes with the passage and the source.
curl -sS -X POST "https://aiuby.com/api/platform/knowledge/search" \
  -H "Authorization: Bearer $AIUBY_TOKEN" -H "Content-Type: application/json" \
  -d '{"query":"return deadline","limit":5}'

What it does not do

  • It does not read scanned PDFs: there is no OCR, and a PDF without text is refused on upload.
  • An API key cannot create bases, delete documents or read a document's full content.
  • A document uploaded with a key is visible to the whole workspace; restricting it to people is done only in the UI.
  • The indexing queue accepts up to 20 pending documents per workspace.

Models & Gateway

One endpoint for every model, with rules and cost

The Gateway is the door every model call goes through: calls from your code, from chat, from agents, prompts and flows. Before calling the provider, it checks the key, the allowed model, the budget, the per-minute limits and the sensitive data policy; afterward, it records usage and cost.

The API follows the OpenAI chat format, including for models from other providers: the Gateway translates the request and the response. Switching models means changing an identifier, or not even that, when the code uses the name of a workspace route.

How it works

  • A catalog with models from Anthropic, OpenAI, Google Cloud and open models served by Google Cloud.
  • Allowed per workspace and restricted by role, area and person; a model outside the list returns 403.
  • Routes: an alias that points to one or more models, with fallback when the first one fails or runs out of budget.
  • Streaming in the OpenAI format, with the sensitive data policy also applied to the text as it arrives.
  • A project header to split budget and reporting by application.
  • The company's own connection to a provider: usage is paid directly to the provider, and policies and audit still apply.
Through the API Chat in the OpenAI format with a model allowed in the key's workspace.
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?"}
    ]
  }'

What it does not do

  • Models run on the providers' servers; processing may happen outside Brazil.
  • There is no public embeddings route for API keys.
  • Fallback only applies before the first chunk of the response: there is no model switch in the middle of a stream.
  • The request body is limited to 4 MB, and a field outside the accepted list is refused rather than ignored.

Skills registry

Skills reviewed by someone else before they reach coding agents

A per-organization catalog of the skills your team's coding agents use (Claude Code, Cursor and similar). Each skill has a unique name and versions; each version is the manifest, the SKILL.md file and the sha256 of the content, and it does not change once saved.

A version moves through draft, reviewed, published and retired. The author does not review: the four-eyes rule is enforced on the server and in the database. Only published versions go out, through API v1 or the MCP server, and whoever downloads checks the hash before installing. The platform stores, reviews and distributes; it does not execute skills.

How it works

  • Manifest with name, description, version, owner, inputs, outputs, declared permissions and compatibility.
  • A new version must be higher, in semver, than all existing ones.
  • Writing, reviewing, publishing and retiring belong to owners or admins, and each step goes into the audit log.
  • Download with a key scoped to "Download published skills"; without a version, the highest published one is returned.
  • Through the MCP server, the skill type lists name, owner, published versions and sha256, and returns the manifest and SKILL.md.
Through API v1 Lists published skills, downloads a version and checks the content sha256.
curl -sS https://aiuby.com/api/v1/skills -H "Authorization: Bearer $AIUBY_TOKEN"
curl -sS "https://aiuby.com/api/v1/skills/revisar-pr?version=1.0.0" -H "Authorization: Bearer $AIUBY_TOKEN" > skill.json
# Check the hash before installing:
jq -r .data.content skill.json > SKILL.md
test "$(sha256sum SKILL.md | cut -d' ' -f1)" = "$(jq -r .data.sha256 skill.json)" && echo ok

What it does not do

  • The platform does not execute skills: it only stores, reviews and distributes them.
  • Manifest permissions are the author's declaration; the platform neither grants nor enforces anything in the coding agent.
  • The platform CLI has no skills command: download is through API v1 or the MCP server.
  • Drafts, reviewed versions and retired versions are not served through the API or MCP.

Execution traces

Every run opened step by step, with cost and timing

The trace is the run seen from the inside: every model call, every tool used, every wait for approval and every policy decision becomes a step, with that step's cost and latency. You can see where the agent spent, where it was slow and where it stopped, and the platform Assistant can read the open run (steps, error, cost and output) to answer questions about it.

Runs with the same session key, such as a ticket number, appear together and in order, with the cost added up. Agents running outside AIUBY land in the same place: any OpenTelemetry SDK with the OTLP HTTP JSON exporter sends spans to /api/v1/otel/v1/traces with a key scoped to agents:trace, and spans with the same session join the internal runs.

How it works

  • Step by step for each agent and flow run, with type, tool, detail, cost and latency; cost linked to the Gateway usage record.
  • Sessions by a free-form key, set when the run is created or later, combining different agents and external spans.
  • Redaction on span ingest: attributes with a credential name are dropped, and the rest goes through secret and personal data masking.
  • gen_ai.* conventions become model and tokens; session.id groups the span into the session; up to 1,000 spans per call.
  • Workspace AI-BOM in CycloneDX 1.6, with agents, published versions, tools, autonomy, environments and models.
  • Approval and governance decisions appear at the exact point in the run where they happened.

Example use case

A team runs one triage agent outside AIUBY and another inside it, both handling the same ticket. The external agent points its OTLP exporter at AIUBY with a traces key and sets the ticket number as the session; the internal agents receive the same key. In the ticket session, the person in charge sees the order of steps, where latency concentrated and the combined cost of the internal runs, with no tokens or personal data stored.

What it does not do

  • It is read-only: the trace does not change or replay a run, and the traces key reads nothing.
  • It only accepts OTLP in JSON; protobuf is not accepted. External spans carry model and tokens, with no calculated cost.
  • The platform does not export its own traces in OpenTelemetry.
  • An API key can only check the runs it started itself.

AI and limits

What AI does here, and what it never does on its own

Does

  • Answers and cites the document the information came from.
  • Runs the agent or flow steps with the tools enabled for that version.
  • Scores eval cases against the criteria your team wrote.
  • In catalog agents, looks up and cites the evidence (specialists) or drafts a proposal for review (workers).

Never does

  • An agent tool with side effects never runs without a person's approval. The exception is a tool the admin marked as low risk in governance, within the action budget the admin set.
  • In a flow, the connector runs without approval, including on a schedule, if the designer did not place an approval step before it.
  • It never uses a model outside the list enabled in the workspace.
  • It never executes skills: the skills registry only stores, reviews and distributes them.
  • It is instructed not to follow commands that appear inside documents. That lowers the risk without removing it, and agent tools with side effects still depend on approval.

Governance and security

Rules the code enforces

  • Models enabled per workspace and restricted by role, department and person.
  • API keys scoped by function (for example, knowledge search only). No key can approve an agent action.
  • Budget per workspace and a cap per organization. With no balance left, the call is refused.
  • A tool only runs if it is in the agent version and the person who triggered it holds its permission. Approvers need the approver permission.
  • Approvals expire after 24 hours, and a tool blocked by workspace policy is refused even after approval.
  • Published versions of agents, prompts, flows and documents never change.
  • Document content and external tool responses are treated as data, never as instructions.

Integrations

What it connects to

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

  • Anthropic, OpenAI and Google CloudModel providers connected to the gateway.Models & Gateway
  • Your company's n8nFlows call automations with a signed callback.Workflows
  • MCP serversYour company's tools, reviewed before use.Agent Management
  • PostgresRead-only queries against a company database.Agent Management
  • Claude Code and CursorCoding agents download published skills and verify the hash.Skills registry
  • MCP clientsRead engineering data and published skills through the MCP server, with an API key.MCP server
  • API and webhooksChat, knowledge search and runs of agents, prompts and flows over the API.API, CLI & keys
  • OpenTelemetry (OTLP HTTP JSON)Agents running outside AIUBY send spans, redacted on ingestion.Execution traces

Workflows

Workflows: processes built from blocks

Agents, knowledge base searches, n8n automations and human approvals chained in one design, with ready-made flows to get started, a published version, scheduling and API runs.

See how flows work
  • Start
  • Agent
  • Knowledge base
  • Connector (automation)
  • Human approval
  • Condition
  • Join
  • Response (end with template)
  • End
  • Run another flow

Tools

Data from outside the base, with the source attached

Beyond the knowledge base, an agent can look up the official exchange rate and query a company Postgres database, read only. Both tools return the source with the result, and a failure comes back as an error, never as a made-up number.

  • open data

    PTAX exchange rate from the Central Bank of Brazil

    Buy and sell rates from the Central Bank of Brazil open data, for 10 currencies (AUD, CAD, CHF, DKK, EUR, GBP, JPY, NOK, SEK, USD). It returns the latest bulletin and the latest closing PTAX, with date, time and source; given a date, the most recent rate up to that date.

    • Lookup only: it does not ask for approval, because it has no side effects
    • If the Central Bank does not respond, the agent says the rate is missing and does not convert
  • optional

    Read-only Postgres connector

    A workspace admin registers the database and picks the released tables or views. The agent sees the catalog of those tables and runs one SELECT query at a time, inside a read-only transaction, with a maximum time of 5 s and up to 200 rows and 50 columns per result.

    • A query outside the table list, with writes or with a function not on the list is refused, with the reason
    • Every query goes to the audit log with the SQL (sensitive data replaced by a placeholder), the row count and the duration; never the data
    • Password encrypted; no one can see it after registration

To use the connector

  1. Postgres with a public address and TLS
  2. Connection allowed through the firewall from AIUBY
  3. A user with SELECT only on the released tables or views, without superuser
  4. Recommended: a read replica and views with only the columns needed

Tool limits

  • Postgres only: MySQL, SQL Server, ERPs and BI tools have no connector.
  • A database only on the internal network, with no public address, cannot be reached.
  • SQL validation is an extra barrier; the barrier that counts is the SELECT-only user required from the customer.
  • A heavy query uses CPU and memory on the customer database for up to 5 s.

FAQ

Straight answers

What can I use today?

Available: Agent Management, Specialist & worker agents, Agent governance, Agent operations, Workflows, Evals, Prompt & config registry, Knowledge bases, Models & Gateway, Skills registry, Execution traces. Self-service: add it from your account.

Do I need accounts with the model providers?

No. Usage runs through AIUBY's account and is drawn from the prepaid balance. If you prefer, your company's own provider connection works too, and then you pay the provider directly.

Can an agent act without anyone approving?

Available: Agent Management, Agent governance, Workflows. Not by default. An agent tool with side effects stops and waits for a person to decide, while agents that only read and answer need no approval. In agent governance, the admin can waive approval only for tools they marked as low risk, with an action budget per run and per day. This is off by default, and the kill switch shuts down one agent or all of them at once. Flows work differently: approval is a step the designer places before the connector, and a flow without that step calls your n8n directly, including on a schedule.

Can I use evals as a gate in CI?

Available: Evals, Agent operations. Yes, through API v1. With a key scoped to agents:eval, the pipeline lists and creates cases, runs an agent's suite against a version and reads the result. The same operations exist as MCP server tools. Real runs reviewed by people also become suite cases, with personal data masked.

Do specialist agents and workers apply changes?

Available: Specialist & worker agents. No. Specialists only read and answer, citing the evidence. Workers only propose, and the proposal is decided by someone else, never by the person who started the run. Each one has caps on steps, cost and time.

Is there OpenTelemetry tracing?

Available: Agent Management, Execution traces. On ingestion, yes. Every agent run shows its steps with cost and latency, and runs that share a session key appear together with the total cost. Agents running outside AIUBY send spans through the OTLP HTTP exporter in JSON, with a key scoped to agents:trace. Attributes named like credentials are dropped, and the rest goes through personal data masking. The platform does not export its own traces as OpenTelemetry.

Where are my documents and conversations stored?

Documents, indexed chunks and conversations stay on the platform, with per-document permissions. AIUBY hosts the platform and its database. Organizations share the database, and each one only sees its own rows, enforced by row-level access rules. The daily backup is encrypted and stored on AWS in the United States. Model calls go to the provider you choose, which may process data outside Brazil. If the organization is closed, documents, conversations, agents, flows, prompts and integrations are deleted within 30 days; audit records, usage and invoices are kept.

How much does it cost?

Available: Knowledge bases, Agent Management. Knowledge bases and the bundle of agents, flows, evals and prompts each have a tiered monthly fee under their own contract. AI usage is separate and drawn from the prepaid balance. Pricing is on the Pricing page.

Works together with

  • AI & API SecurityThe sensitive data policy runs before every model call.
  • Cost ManagementThe cost of every run shows up by model, key and project.
  • Code AutomationWorkers from the agent catalog deliver code change proposals for human review.

AI Engineering

Self-service: add it from your account.