Skip to content

Delivery measured, with the formula in view

Engineering Intelligence · Engineering metrics and PR review

Pull requests from your GitHub repositories become weekly series, and each PR can get an AI read that says what changed and where to look. On top of the delivery graph, the platform computes DORA indicators by service and team, shows adoption of AI coding tools and answers plain-language questions, always with the formula or the evidence alongside. Team trees, a single identity per person, work items sent through the API, goals and dashboards bring the same numbers down to each team.

The problem

What this product solves

Measuring engineering often ends up as a pretty dashboard with undefined metrics, or a spreadsheet nobody updates.

With AI writing more code, review becomes the bottleneck, and the team needs to know where to spend attention.

And the bill for AI tools grows while nobody can say how many seats sit idle or what changed in delivery.

updated

Who uses it, and for what

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

  • Engineering leadershipTrack deployment frequency, change failure rate and lead time per team, with the same formula for everyone.DORA metrics
  • PR reviewerKnow what the PR changes and where to look before opening the diff.PR review
  • Technology executivesSee who uses AI tools, what idle seats cost and how delivery moved over the same window.AI efficiency

Features

What the product does

Self-service: add it from your account.

  • PR flow

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

  • PR review

    AI reading of the PR, with metered cost and audit.

  • Code Review

    Structured AI pull request review with per-repository team rules: findings by file and line with suggestions, a fixed-formula risk score, reviewers suggested from CODEOWNERS and the graph, a gate the CI can query, and a GitHub branch policy check. Publishing to the PR and automatic review are separate options.

  • 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.

  • DORA metrics

    Deployment frequency, change failure rate (failure, aborted rollout, rollback or service incident within a configurable window), lead time through the commit→PR link and time to restore, per service, team and workspace, with weekly trend, PR rework and AI spend side by side (correlation, not cause). Sources: AIUBY Compute, Kubernetes rollouts, Cortex and Incidents, with a per-workspace profile of what counts as production and as failure; deployments outside AIUBY are not ingested. Lead time only when the revision or rollout carries the commit.

  • Teams and goals

    Team tree with a unified developer identity (Git, tickets, chat), a configurable DORA profile, work items pushed through the API, sprints, effort by category, backlog hygiene, AI adoption with a survey (groups only), goals with alerts, dashboards, CSV export and a report through API v1.

  • Graph questions

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

  • AI efficiency

    GitHub Copilot, Claude Code (Anthropic Admin API) and Cursor adoption and spend per team, through the official admin APIs: idle seats with wasted cost and merged PRs side by side, as correlation, not cause. Per-person view only for owners/admins; no prompts or code. What each API does not provide is shown as not collected.

PR flow and PR review: in detail

  • Connects to GitHub repositories
  • Delivery metrics: PRs merged per week, time to merge and age of open PRs
  • AI reading of each pull request: what changed and where to look
  • Repository documentation indexed in Knowledge

What it does not do

  • The metrics measure pull requests; they are not DORA metrics.
  • It does not replace human review: the reading gives no score and approves nothing.
  • GitHub only: GitLab and Bitbucket are not supported.

How it works

From start to audit record

  1. Connect and measure PRs

    GitHub repositories linked to the workspace. PRs arrive through sync and webhook and become 28-day series.

  2. Read the PR

    The reviewer asks for the AI read: what changed, where to look and what the diff does not show, with cost and audit.

  3. See workspace delivery

    Deployment frequency, change failure rate, time to restore and PR cycle time, with formula, sample and window.

  4. Slice by service and team

    The four DORA indicators with weekly trends, PR rework and an alert when a team gets worse.

  5. Organize by team

    Team tree, a single identity per person and work items through the API: sprints, effort by category, hygiene, goals with alerts and dashboards.

  6. Compare with AI usage

    Seats, daily usage and spend for Copilot, Claude Code and Cursor per team, next to merged PRs.

  7. Ask the graph

    A plain-language question returns sentences with cited evidence, or "Insufficient data" with the reason.

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.

PR flow

The same pull request series for every team

Pull requests from the GitHub repositories linked to the workspace come in through sync and a signed webhook, and become three views: PRs merged per week, time from opening to merge, and open PRs with the age of each one.

Each metric shows its written definition alongside, the window used and what it cannot see. The calculation uses no AI: it is arithmetic on open, merge and close dates.

How it works

  • Fixed 28-day window: PRs merged in the window, divided by four weeks.
  • Time to merge at p50 and p85, from PR opening to merge; it measures waiting and review together.
  • Open PRs that are not drafts, with the median age.
  • Nearest-rank percentile: the number shown is always a value that actually happened.
  • GitHub token stored encrypted, and a webhook with its own secret per repository, which can be rotated or removed.
  • Synced PRs feed the delivery graph, which produces the delivery and DORA metrics.

Example use case

An engineering manager wants to know whether review became a bottleneck after the team doubled in size. She links the repositories to the workspace and, in the weekly meeting, the team looks at p85 time to merge and the open PR queue, with each number's definition on screen. The conversation moves from impressions to the PRs that got stuck.

What it does not do

  • It only reads GitHub.
  • Merges done outside GitHub, direct pushes to the default branch and PRs combined in a squash do not show up.
  • Time to merge starts when the PR opens, not at the first commit.
  • It does not measure people: the series are per repository and workspace.

PR review

Know what a PR changes before you open the diff

When someone in the workspace asks, the platform reads the pull request at the current version of the code and returns three things: what changed, in a few lines; where the review should look carefully, citing files; and what the diff does not allow it to assess.

The title, description and diff go to the model through the platform gateway, within the workspace budget and model rules. Each reading has its cost metered and goes into the organization's audit log.

How it works

  • A person requests the reading; AI reads nothing without a request.
  • The same PR version is never read twice: asking again returns the stored reading, at no new cost.
  • The diff is cut at 60 thousand characters; when it is cut, the reading says it is partial.
  • PR text is treated as third-party data: instructions written in the title, description or diff are not followed.
  • Up to 20 new readings per person per hour; stored readings do not count.
  • The reading appears in the platform, for anyone with access to the workspace.

Example use case

A forty-file PR lands on Friday afternoon. The reviewer requests the reading and gets the summary of the change, the three files where the billing rule was changed and a note that the database migration cannot be assessed from the diff alone. Review starts with those files, and the decision to approve stays with the person.

What it does not do

  • It does not approve, score or assign a risk level.
  • It does not comment or write anything in GitHub.
  • It does not claim the code is correct: the reading sees only the diff, not the whole repository.
  • People with a read-only role in the workspace cannot request readings.

Code Review

PR review with your team's rules

Code Review reads a pull request diff with the rules the team wrote for that repository and returns a summary and findings by file and line, each with a replacement suggestion when there is one.

The PR risk score comes from a fixed formula (findings, sensitive path and size), not from the model. AIUBY approves and merges nothing: a person decides on each finding.

How it works

  • Per-repository rules, versioned, added to the workspace default rules; each review records which rules it ran with.
  • A finding that cites a line outside the diff is discarded and counted.
  • Reviewers suggested from the base branch CODEOWNERS and from the service owners in the graph; incidents from the last 90 days come in as context.
  • A gate your CI can query: pass, fail or no review for that commit.
  • Publishing to the PR with a manager's click, as a comment with a suggestion block per line.
  • Branch policy: protection, rulesets and CODEOWNERS read from GitHub and compared against what is expected.
CI gate, through API v1 Read-only, with a key scoped to engineering:read.
GET /api/v1/code-review/check?repo=<owner/name>&pr=<number>&sha=<commit>&base=<commit>
GET /api/v1/code-review/reviews
GET /api/v1/code-review/reviews/{id}
GET /api/v1/code-review/branch-policy
GET /api/v1/code-review/metrics

What it does not do

  • GitHub only; the review sees the diff, not the whole repository.
  • AIUBY does not write commit statuses to GitHub: the CI queries the gate.
  • Whatever the token cannot read in the branch policy shows as not checked.
  • Reviewer and label suggestions are only suggestions on screen; nothing is assigned in GitHub.

Delivery metrics

Delivery indicators with formula, window and a reason when data is missing

The workspace delivery indicators come from the delivery graph and from model gateway usage: deployment frequency, change failure rate, time to restore, PR cycle and AI usage, over a window of 1 to 180 days.

Each indicator comes with the formula spelled out and the sample size. When the data is not enough, the value comes back empty with the reason written out. No number is estimated.

How it works

  • Deployment frequency (completed without failure in the window, per week) and failure rate (failed over completed).
  • Time to restore as the median between incident opening and resolution, and PR cycle at p50 and p85, from PR opened to merge.
  • Lead time from CI: the median between the start of a commit's first CI run and the start of the deployment of that same commit, across the window's completed deployments.
  • Open security findings by severity, per team (owner of the repository or of the service built from it), with the trend over the last 8 weeks: opened, fixed and still open at the end of each week.
  • Workspace AI usage in the same window (metered calls, tokens and cost), side by side with delivery, as correlation and not as cause.
  • The same numbers through API v1 and the MCP server (delivery_insights type), read-only.
Through the API Returns the delivery indicators for the requested window, with formula and a reason when data is missing. The key needs the engineering:read scope.
# Base: https://aiuby.com/api/v1
GET /engineering/insights/delivery?days=30
Authorization: Bearer <key>

What it does not do

  • Only deployments made through AIUBY Compute count; deployments made by other tools are left out.
  • Lead time from CI only links Compute deployments to AIUBY CI runs; a commit without CI on the platform is left out of the sample.
  • There is no breakdown by service or team: the reading covers the whole workspace.
  • A deployment that ended stopped without failure counts as completed.

DORA metrics

The four DORA metrics by service, team and workspace

Deployment frequency, change failure rate, lead time for changes and time to restore, calculated from the platform's own sources: Compute deployments, Kubernetes delivery rollouts, Cortex pull requests and incidents from the incident module. The per-team breakdown uses the service owner in Developer Portal.

The workspace DORA profile decides what counts: which environments are production, whether direct Compute deployments and Kubernetes rollouts are included, and whether revision rollbacks and incidents count as failures; the report shows the profile used. The formulas are public and fixed, the trend is weekly, and PR rework and AI spend sit alongside, as correlation and never as cause. An indicator with no data or no link shows as not measured, with the reason.

How it works

  • Failure rate counts failed deployments, aborted rollouts, revision rollbacks and incidents opened on the service within a configurable window of 1 to 168 hours (24 by default).
  • Lead time at p50 and p85, through the link between the commit of the deployed revision and the PR: from PR opening to the start of the production deployment. Kubernetes rollouts in production come in through the rollout commit; a rollback does not count as a deployment.
  • Rework and quality of merged PRs: reverts, per-file rework within 21 days, size, time to first review and cycle.
  • AI cost per deployment and per PR; teams with fewer than 3 people have spend hidden, and nothing is shown per person.
  • Weekly per-team alerts when an indicator worsens beyond the configured threshold (30 percent by default) against the average of previous weeks.
  • Reference bands from the public DORA research report appear for context, with the source, and not as targets.
Through the CLI and the API The MCP server exposes the same reading as the dora type, with the days, service and team filters.
# Breakdown by service or team, window of 7 to 180 days
aiuby dora [--service S | --team T] [--days N] [--json]

# The same reading through API v1, with an engineering:read key
GET /api/v1/engineering/dora?days=&service=&team=

What it does not do

  • Deployments made outside AIUBY (GitHub Actions, Argo and others) are not included.
  • Lead time is only measured when the Compute revision or the rollout carries the source commit; the start is PR opening, not the first commit.
  • A Kubernetes rollout without a catalog service is left out of rollback and incident attribution.
  • Per-line churn is not measured: it would require the history of every line, which the platform does not keep.

Teams and goals

Metrics per team, with a single identity and goals that alert.

Teams sit in a tree, and each person has a single identity that combines their GitHub, GitLab, Bitbucket, Jira, Linear, Slack, Teams, CI and email accounts. That way DORA, PR throughput, work items, survey and AI adoption roll up per team, including child teams, without counting the same person twice.

Work items arrive through API v1, sent from inside your network: AIUBY does not open a connection to your Jira or Linear. With them come sprints with committed and delivered work, effort by category, backlog hygiene and defect share, next to the team's DORA. Goals with targets and saved dashboards complete the tracking, and the report comes out as CSV in the UI and as JSON through API v1.

How it works

  • Automatic matching: the person is linked to the platform account by email and inherits the GitHub login confirmed in AI adoption; a PR counts for the person by login, a work item by assignee.
  • Work items via POST to API v1, up to 500 per call, created or updated by the item source and key, with a key scoped to engineering:ingest.
  • Effort by category on merged PRs and completed items, with workspace rules by title prefix (feat, fix) or item type; an item's explicit category wins.
  • Hygiene: items with no assignee, no estimate or no category, items stuck in progress for more than 14 days, PRs open for more than 7 days, and defects created versus resolved.
  • AI adoption per team and a monthly survey on experience and AI helpfulness, from 1 to 5; a group with fewer than 3 people or responses is not shown, and the per-person view is for admins only.
  • Goals with targets on 11 indicators and an alert recorded in the audit log when a goal starts failing; dashboards with up to 24 widgets per indicator and team.

Example use case

The platform team writes a script that sends items from the internal Jira every hour through API v1. Leadership creates each team's lead time goal for the quarter and a dashboard with DORA, defects and effort by category. When a team starts missing its goal, the alert shows up in the audit log and the conversation starts with the number and the formula on the table.

What it does not do

  • It does not fetch items from Jira or Linear on its own and does not import the team tree from HR or GitHub: items arrive through the API and teams are registered.
  • Goals are evaluated when someone asks in the UI; the alert stays in the audit log, with no email.
  • Dashboards show numbers and tables, with no charts or free-form queries.
  • Categories count items and PRs, not hours or cost; the intelligence API v1 carries no personal data.

Graph questions

Ask in Portuguese and get the answer with the evidence

A person writes the question on screen (who owns a service, what depends on it, which deployments followed a change) and gets an answer in which every sentence cites the delivery graph evidence it came from.

The model works in two bounded steps: first it picks an intent from a closed catalog; then it selects and orders sentences that the system built from the query rows. The model never writes a fact, and a citation the query did not return throws out the entire answer.

How it works

  • Closed catalog of intents: owners, dependents, findings affecting a service, incidents, deployments after a change, cost after a release and changes before an SLO burned.
  • The query runs with workspace isolation: the person only receives what they are allowed to read.
  • When the evidence is not enough, the answer says "Insufficient data" with the reason, instead of filling the gap.
  • Workspace memory: up to 50 short rules written by admins ("the checkout service is critical"); the answer lists the ones it used.
  • Every question goes through the model gateway, with metered cost, budget and workspace policy.
  • History keeps the question without sensitive data, the intent, the evidence and the cost; the model text is not stored.

Example use case

During a checkout incident, the on-call engineer asks which deployments happened on the service in the last few hours and who owns the payment gateway it depends on. The answer arrives in short sentences, each marked with its evidence: the deployment, the PR, the ownership edge. If the graph lacks the link, the answer says the data is insufficient and why.

What it does not do

  • Natural-language questions exist only in the UI: the API and MCP offer the structured query, with no model and no cost.
  • It does not answer outside the intent catalog or about anything not in the graph.
  • Questions of up to 500 characters, capped at 30 per person per hour.
  • It takes no action: it only reads the graph.

AI efficiency

Who uses AI tools and what idle seats cost

GitHub Copilot, Claude Code and Cursor adoption and spend per team, read from each vendor's official admin APIs. Collection brings in seats and aggregated daily counts: nothing is installed on machines, and no prompt or code is read.

The view shows idle seats with the monthly wasted cost and puts merged PRs next to AI usage, in the same window, as correlation. It is not a measure of individual productivity.

How it works

  • Idle seat: paid and unused for 30 days; a seat assigned less than 30 days ago with no use is "new", not idle.
  • Monthly waste in USD and BRL, based on the seat cost an admin enters when connecting.
  • The link between the provider identity and the workspace person only counts after an owner or admin confirms it.
  • Default view by team; for non-admins, teams with fewer than 3 people are grouped under "Other teams".
  • Per-person view only for owners and admins, in alphabetical order, with no ranking and recorded in the audit log.
  • Whatever each API does not provide (tokens, daily cost, sessions) shows as not collected, with the reason.
Through the API Returns adoption and spend per team. The API never returns per-person data; the key needs the engineering:read scope.
GET /api/v1/engineering/ai-efficiency?days=30
Authorization: Bearer <key>

What it does not do

  • It does not read prompts, code or sessions: only seats and aggregated daily counts.
  • Copilot only reports the GitHub login, with no email: linking to the person is manual.
  • It does not collect seats on claude.ai Team or Enterprise plans or usage signed in with a subscription.
  • Seat cost does not come from any API: it is the value the admin enters.

AI and limits

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

Does

  • Summarizes what the PR changes and points to where review should focus, citing files.
  • In graph questions, picks the query from a closed catalog and orders sentences the system built from the evidence.

Never does

  • Never approves, scores or replaces human review.
  • Never comments on GitHub or writes to the repository.
  • Never states facts on its own: an answer citing something the query did not return is discarded entirely.
  • Never computes metrics: PR series, delivery indicators and DORA are fixed-formula calculations, with no model.

Governance and security

Rules the code enforces

  • The GitHub token and AI tool credentials are stored encrypted. Credentials never appear in audit, logs or responses.
  • Every PR read and every graph question goes through the model gateway, with recorded cost, budget and the workspace model rules.
  • An indicator with no data or no link comes back as not measured, with the reason. No number is estimated.
  • AI usage and delivery appear side by side as correlation, never as cause, and with no ranking of people.
  • AI adoption is shown per team. The per-person view is limited to owner and admin, is audited, and the API never returns per-person data. Adoption and surveys for groups with fewer than 3 people or responses are hidden.
  • Text from PRs and repositories is treated as third-party data: instructions written in it are not followed.
  • API v1 and the MCP server are read-only, with their own scoped key tied to a workspace.

Integrations

What it connects to

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

  • GitHubPull requests through sync and signed webhooks.PR flow
  • Model gatewayThe model used for PR reads, with metered cost.PR review
  • AIUBY Compute, Kubernetes and IncidentsDeployments, Kubernetes delivery rollouts and incidents per service, the sources of the DORA indicators.DORA metrics
  • AIUBY CIThe first CI run of a commit marks the start of lead time until that commit is deployed.Delivery metrics
  • 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.Teams and goals
  • GitHub Copilot, Claude Code and CursorSeats and aggregated daily usage, through each vendor's official admin APIs.AI efficiency
  • Delivery graphPRs, deployments, services and owners linked, with the origin of each data point.Knowledge Graph
  • API v1 and CLIDelivery indicators, DORA, AI adoption and the intelligence report through read endpoints. DORA also through the aiuby dora command.API, CLI & keys
  • MCP serverDelivery and DORA indicators for coding assistants, read-only.MCP server

FAQ

Straight answers

What can I use today?

Available: PR flow, PR review, Code Review, Delivery metrics, DORA metrics, Teams and goals, Graph questions, AI efficiency. Self-service: add it from your account.

Are these DORA metrics?

Available: PR flow, DORA metrics, Delivery metrics. The PR flow series measure pull requests and are not DORA. DORA metrics computes the four indicators (deployment frequency, change failure rate, lead time and time to restore) per service, team and workspace, with a fixed formula. Delivery metrics is the summary view for the workspace. An indicator with no data shows as not measured, with the reason.

Does it work with GitLab, Bitbucket or deployments made outside AIUBY?

Available: PR flow, DORA metrics, Teams and goals, Repositories. Partly. PRs for the indicators come from the GitHub API, and the deployments that count are Compute deployments and AIUBY Kubernetes delivery rollouts. Deployments made by other tools are not included. Each person's identity merges accounts from GitHub, GitLab, Bitbucket, Jira, Linear, Slack and Teams, and work items arrive from any tool through API v1, sent by you. The GitLab repository connector is part of Repositories, in Software Delivery.

Does PR code go to an AI model?

Available: PR review. Only when someone asks for the read. The title, description and diff, truncated to a maximum size, go to the model through the platform gateway, and the provider may process them outside Brazil. The read shows up on the platform and writes nothing to GitHub. PR flow series and delivery indicators use no AI.

Does AI adoption show what each person does or writes?

Available: AI efficiency. No. Collection pulls seats and aggregated daily counts from the GitHub Copilot, Claude Code and Cursor admin APIs. No prompt or code is read and nothing is installed on machines. The default view is per team, teams with fewer than 3 people are grouped, and the per-person view is limited to owner and admin, with no ranking and with an audit record.

Can I ask the graph questions through the API or from a coding assistant?

Available: Graph questions. Not in natural language: model-backed questions exist only in the app, with a person present and an hourly cap. Through API v1 and the MCP server there is structured querying of the same graph, with a closed catalog of intents, no model and no AI cost.

Where is my PR data stored?

The platform stores the title, author, state and dates of each PR, plus the reads that were requested. Code is not copied to it, and the diff only goes to the model when someone asks for a read. 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.

How much does it cost?

Available: PR flow, PR review, Graph questions. All features use the Cortex contract, with a tiered monthly fee. Every PR read and every graph question counts toward the organization AI usage, paid from the prepaid balance. Metrics consume no AI. Pricing is on the Pricing page.

Works together with

  • Software DeliveryCompute deployments, Kubernetes rollouts and CI runs are the basis for deployment frequency, change failure rate and lead time.
  • Incident ManagementIncidents per service feed change failure rate and time to restore.
  • Cost ManagementPR reads and graph questions count toward the organization AI usage, by model and key.

Engineering Intelligence

Self-service: add it from your account.