Skip to content

From ticket to a reviewable pull request

Code Automation · Coding agents and PR automation

You write the ticket with its acceptance criteria. AI suggests a plan that a person approves, writes the diff, and an isolated runner applies the change and runs your repository tests. The result is a hashed proposal, reviewed by someone else, delivered as a patch or as a draft pull request.

The problem

What this product solves

Much of maintenance work is predictable: upgrading a dependency, adjusting configuration, fixing the same kind of failure, adding the missing test.

Coding assistants help the person in the editor, but they do not take a ticket and hand back a tested change, with evidence, ready for someone else to review.

And when an agent writes code without guardrails, nobody can say which files it could touch, where the code ran or who approved what.

updated

Who uses it, and for what

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

  • Team maintaining a legacy systemTurn dependency upgrades and repetitive fixes into tested changes ready for review.Ticket to PR
  • Engineering leadershipFree the team from predictable tasks without giving up plan approval and review of every proposal.Ticket to PR
  • QA teamAdd a new test to the repository through a ticket, with a tested patch and review by someone else.Ticket to PR

Features

What the product does

Self-service: add it from your account.

  • Ticket to PR

    Manual ticket → AI-suggested plan approved by a person → validated diff (plan files only, no workflows or secrets) → apply and run the repository tests in the isolated executor → hashed proposal reviewed by someone else → patch for git apply. Draft PR only with the workspace write credential and PR creation turned on; nothing is merged. Tickets come from the app, the session API or other products (accepted test, flag to remove, IaC drift); GitHub Issues and Jira do not become tickets.

  • Code context and verification

    Per-repository code index pushed from CI, searchable by people and agents; verification of each run with checks and evidence (logs, screenshots, traces); optional auto-approval of low-risk changes, which the workspace must turn on, never on production branches without an explicit rule; accepting does not open a PR or merge.

  • Code experts and event-driven flows

    Two installable engineering experts: Code Reviewer (diff against team standards and repository docs) and Change Verifier (PR promise against diff and tests). Flows that run on workspace events (PR, finding, alert, incident, policy decision) and can be exported and imported as an aiuby.flow/v1 JSON document to version in Git.

How it works

From start to audit record

  1. Ticket

    Title, description, acceptance criteria, repository, base branch, runtime image and test command.

  2. Approved plan

    AI reads the file list, the README and the manifest and suggests a plan with up to 12 files. A person approves it, with a justification and the hash of what they saw.

  3. Validated diff

    AI writes the diff and the platform checks it before running: plan files only, no workflows, no secrets, applying cleanly on the base.

  4. Isolated runner

    Shallow clone, git apply and the repository tests, running with no token at all. The final diff is captured before the tests run.

  5. Reviewed proposal

    If it passes, a proposal is created with hash, evidence and security facts about the diff. The person who requested the patch does not decide.

  6. Verification

    Each run gets a verdict with the runner checks and your CI checks, linked to the evidence.

  7. Delivery

    A patch for git apply or a draft pull request on a new branch based on the tested commit. Your team does the merge.

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.

Ticket to PR

A written request becomes a tested change, ready for review.

Ticket to PR takes a coding task from request to delivery in six stages, each with a defined owner: ticket, plan, patch, run, proposal and delivery. AI suggests the plan and writes the diff. The platform validates every output before anything runs. The isolated executor applies the patch and runs the repository's own tests. Two different people decide: one on the plan, another on the final proposal.

The output is either a patch for git apply, with a verifiable hash, or a draft pull request on a new branch created on top of the tested commit. Merging always stays with your team.

How it works

  • A ticket carries a title, description, acceptance criteria, workspace repository, base branch, execution image (node22, python312 or go126), an optional setup command and a test command. Besides the UI and the API, other products open tickets with the request ready: the .spec.ts of an accepted test in Test Automation, the removal of a stale flag in Feature Management and the fix for an IaC drift detected by Software Delivery.
  • The plan is JSON with up to 12 files (modify, add or delete), steps, tests and risks. Every path is checked against the repository tree. The plan records a sha256 and waits for a person to approve it, with a justification and the hash they saw.
  • The diff is validated before it runs: up to 24 KB and 20 files, plan files only, no .github/workflows, .env, keys, credentials or .git, no secrets in new lines, no binaries, renames, symlinks or mode changes, and it must apply cleanly on the base read from GitHub.
  • Execution in the isolated executor: shallow clone, git apply, capture of the final diff before the repository commands run, and tests running without any token. The result comes back signed, with a secret derived only for that run.
  • The proposal carries a hash, evidence and history in the agent catalog, plus security facts extracted from the diff (secrets, disabled TLS, eval, shell, concatenated SQL, weak hashes, open CORS). Whoever requested the patch does not decide on the proposal.
  • Bounded loop per ticket: 3 iterations by default (5 at most), an AI budget per ticket, one iteration at a time and one patch per plan. A new plan receives the reason the previous one failed.
Through the API The session routes follow the flow: ticket, plan, plan decision, patch, diff, proposal decision and draft PR. The API v1 route only reads the loop state.
POST /api/platform/code-automation/tickets
POST /api/platform/code-automation/tickets/<id>/plan
POST /api/platform/code-automation/plans/<id>/decision      {decision, reason, sha256}
POST /api/platform/code-automation/tickets/<id>/patch
GET  /api/platform/code-automation/runs/<id>/patch          (diff, x-aiuby-sha256 header)
POST /api/platform/agent-catalog/proposals/<id>/decision
POST /api/platform/code-automation/runs/<id>/pull-request

GET  /api/v1/code-automation/tickets                        (key with engineering:read)

What it does not do

  • It does not take tickets from GitHub Issues or Jira: input comes from the UI, the session API or another AIUBY product.
  • It does not merge, force-push or reuse branches. The draft PR requires PR creation to be turned on and the workspace write credential; without them, the delivery is the patch.
  • It does not do semantic code search: the plan reads the tree, the README and the manifest, and the model receives whole files, within size caps. Large repositories may call for smaller tickets.
  • The test is the repository's declared command, with no JUnit report or coverage. Security facts come from fixed rules on the diff, not from the executor scanners. The PR writes files with mode 100644, so a changed executable script loses its execute bit.

Code context and verification

Agents that know the code, and changes that come with proof.

Code context gives Code Automation what a reviewer expects: a repository index to find where to make changes, proof that the change works and a clear rule for what can proceed without a second person.

Auto-approval is optional. It starts off, and the workspace decides whether to turn it on and how far it reaches. Even when on, it only applies to low risk calculated by a fixed rule, never touches a production branch without an explicit customer rule, and only records acceptance of the proposal. A person still requests the pull request, and your team owns the merge.

How it works

  • Per-repository index: CI sends the files of a commit, and the platform stores path, language, symbols (functions, classes, types, Terraform resources) and content, with text search for people and agents.
  • Verification with evidence: each run gets a verdict with the executor checks (exit code and duration of each step, diff security) and, when your CI sends them, its own checks with links to logs, screenshots, traces and the review environment.
  • Optional auto-approval: with the policy on, a low-risk proposal within the file and line limits, on allowed paths and branches and with passing verification, is accepted without a second person.
  • Production branches (main, master, production, release) stay out of auto-approval unless the customer marks an explicit rule.
  • Automatic acceptance is recorded in the proposal history and the audit log, as system:auto-approval with the reason. A person still requests the draft PR.

Example use case

The team turns the policy on only for the docs/ folder on the develop branch, with up to three files and fifty lines. A text fix requested in a ticket passes the executor tests and is accepted on its own, with the verdict and logs attached. A medium-risk change to the payments code still waits for review by someone else.

What it does not do

  • It does not merge pull requests or open PRs on its own: accepting records the proposal decision.
  • The index does not read GitHub on its own: the customer's CI sends the files, up to 64 KiB per file.
  • The policy starts off and never applies to medium or high risk. Risk comes from a fixed rule on the diff, with no model involved.
  • It does not spin up the PR review environment or take screenshots on its own: evidence links come from the customer's CI.

Code experts and event-driven flows

Supporting review, evidence-based verification and event-driven automation.

Two engineering experts install from the solutions catalog, on top of the repository documentation that Cortex indexes and the standards your team writes. The Code Reviewer takes a pasted diff and flags each issue with file, line, rule and source, as blocking or as a suggestion. The Change Verifier takes the PR promise, the diff and the test results and gives a verdict per promise: verified, failed or insufficient.

Agent flows that automate engineering gain two capabilities. A published flow can run on a workspace event, such as an opened PR, a new finding, an alert, an incident or a policy decision, with the event as input. And each flow can be exported as an aiuby.flow/v1 JSON document, with sorted keys and a hash, to version in Git, then imported back as a new draft flow.

How it works

  • Read-only experts: they search knowledge bases, cite the base and title of each rule they use, and treat pasted diffs, logs and descriptions as untrusted data.
  • A secret in pasted text is flagged by line, without repeating the value. A truncated log never becomes "verified".
  • Each expert ships with a sample base, marked as fictional, and an eval suite, and starts as a draft for the team to adjust.
  • Trigger by event type: one run per event, up to 30 per hour per trigger, on behalf of whoever created the trigger. Flow events do not trigger flows.
  • An imported document does not publish itself: publishing checks the graph and the references in the target workspace.

Example use case

The tech lead installs the Code Reviewer and writes in the standards base that concatenated SQL and empty catch blocks are blocking. Before opening the PR, the developer pastes the diff and gets both blocks with the rule cited. A flow triggered on every new finding passes the finding to the team's triage agent, and that flow's document is versioned in the platform repository.

What it does not do

  • The experts do not comment on the PR, approve it or read it on their own: a person pastes the content.
  • The trigger selects the event type, with no filter on content, and is configured through the platform API.
  • The flow document is JSON: there is no YAML, CLI or automatic sync with the repository.

AI and limits

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

Does

  • Suggests the plan: files to modify, add or delete, steps, tests and risks.
  • Writes the unified diff from the approved plan and the file contents.
  • Receives the reason for the previous failure when a new plan is opened for the same ticket.
  • As Code Reviewer and Change Verifier, flags problems and gives a verdict citing the rule and the source, on what the person pasted.

Never does

  • Never runs anything without a plan approved by a person.
  • Never touches files outside the plan, CI workflows, .env, keys or credentials.
  • Never approves its own proposal, merges, force-pushes or reuses a branch.
  • Never receives any token while the tests run.

Governance and security

Rules the code enforces

  • Four eyes: one person approves the plan and another decides the proposal, and the requester does not decide. The exception is optional low-risk auto-approval, which the workspace turns on and limits by files, lines, paths and branches, never on a production branch without an explicit rule. It only records the acceptance: a person still requests the PR.
  • Plan and proposal carry a sha256: the decision applies to the content the person saw.
  • The diff is validated before any run (size, plan files, forbidden paths, secrets in new lines). If it is rejected, nothing goes to the runner.
  • Tests run on the isolated runner, with no token and outside the application infrastructure. The callback is signed with a secret derived only for that run.
  • Bounded loop: 3 iterations per ticket by default (cap of 5), an AI budget per ticket and a daily run cap per workspace.
  • The governance kill switch refuses plans, patches, dispatches and PRs, and cancels the run in progress.
  • The write credential is fine-grained and encrypted, never returned in responses, logs or audit, and never sent to the runner. The code.pull_request.create policy is evaluated and recorded before the PR.

Integrations

What it connects to

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

  • GitHubReads the repository through the API, using the workspace read-only token when it is private, and opens a draft pull request with the write credential.Ticket to PR
  • node22, python312 and go126 imagesIsolated runner environments where the patch is applied and the repository tests run.Ticket to PR
  • Model gatewayPlan and diff are requested from the model through the Gateway: metered cost, budget, policy and sensitive data masking.Ticket to PR
  • Policies and kill switchThe code.pull_request.create policy and the organization kill switch apply to plans, patches, dispatches and PRs.Governance & policies
  • API v1Reads the loop state of each ticket with a key scoped to engineering:read.API, CLI & keys
  • Customer CIYour CI sends the commit code index and its own checks, with links to logs, screenshots, traces and review environments.Code context and verification
  • Solutions catalogCode Reviewer and Change Verifier install as experts over the documentation Cortex indexes.Code experts and event-driven flows

FAQ

Straight answers

What can I use today?

Available: Ticket to PR, Code context and verification, Code experts and event-driven flows. Self-service: add it from your account.

Can an agent merge on its own?

Available: Ticket to PR. No. The delivery is a patch for git apply or a draft pull request on a new branch. Nothing is merged, nothing is force-pushed and no branch is reused. The merge always belongs to a person on your team.

Where is the code changed and tested?

Available: Ticket to PR. On an isolated runner, outside the application infrastructure. It makes a shallow clone, applies the patch, captures the final diff before running the repository commands and runs the tests with no token at all. What gets reviewed is the captured diff, not anything the tests may have changed afterward.

Which files can AI touch?

Available: Ticket to PR. Only the files in the plan a person approved, up to 12 per plan. The platform rejects .github/workflows, .env, keys, credentials and .git, as well as diffs with secrets in new lines, binaries, renames, symlinks or mode changes.

Does the ticket come from GitHub Issues or Jira?

Available: Ticket to PR, AI test authoring, Release monitor and flag cleanup. No. The ticket is written in the app or created through the session API, with title, description and acceptance criteria. Other AIUBY products also open tickets with the request ready: Test Automation, to add the .spec.ts of an accepted test; Feature Management, to remove from the code a flag that serves a single variant; and Software Delivery, to fix IaC drift.

Is any change accepted without the second person?

Available: Code context and verification. Only if the workspace turns on auto-approval, which is optional. With it on, a low-risk proposal within the file and line limits, on allowed paths and branches and with passing verification, is accepted without the second person, and the reason goes into the audit trail. Medium or high risk never qualifies, production branches need an explicit rule, and acceptance neither creates a PR nor merges.

Do I need to grant write access to my repository?

Available: Ticket to PR. Not to receive the patch: downloading it for git apply needs no write credential. The draft pull request requires PR creation to be enabled and a fine-grained workspace write credential, encrypted, separate from the read token, which never goes to the runner.

How much does it cost?

Available: Ticket to PR. This product has no published price. The AI usage of each ticket is metered by the Gateway and limited by a per-ticket budget. When the product has a price, it will appear on the Pricing page.

Works together with

  • AI EngineeringThe tested change becomes a proposal in the agent catalog, with hash, evidence and history, and model calls go through the Gateway with the workspace budget and policy.
  • Cost ManagementThe AI spend of each ticket is metered by the Gateway and counts toward the same AI usage the workspace tracks.

Code Automation

Self-service: add it from your account.