Secure Engineering for Humans and AI

Agentic AI for secure software delivery

AI can now work through a task on its own: read a repository, change code, run tests and open a merge request. Here is what your team can hand over, what access to agree, what to check and who decides.

A human in a pink #Human T-shirt and a transparent assistant in an orange #AI T-shirt review an OTTRA-marked design at a workbench.
Illustrative work scene

In plain English

Four questions before AI touches your code.

Agentic AI carries out a series of steps towards a goal, rather than answering a single question. That makes it useful for real engineering work, as long as people agree the job, the limits and the checks first.

  1. Delegate

    What can a team hand over?

    Small, well-defined work with a result someone can check: add a missing test, explain a failing pipeline, update a dependency or rename a setting across one service. Keep design choices, security exceptions and production changes with people.

    Agree A task with an owner and a clear finish line.

  2. Access

    What access should it have?

    Only what the task needs. Name the repository and branch, the commands it may run and what it must never touch, such as the main branch, secrets, production data and pipeline settings. Give it its own account, so every action is recorded against it.

    Agree A written boundary, settled before work starts.

  3. Evidence

    What evidence should you review?

    The diff, the pipeline results and the AI’s own note on what it changed and why. Check that a new test would fail without the fix, and look for anything changed outside the agreed scope. Treat the output as a draft that can be wrong.

    Agree A draft merge request with results beside the change.

  4. Decision

    Who decides whether to merge?

    A named engineer who is responsible for that code. AI proposes the change. Protect the main branch so it cannot approve or merge its own work. The merge request then records who decided, and on what evidence.

    Agree One accountable decision, on the record.

Illustrated example

One missing test,
from task to merge.

The four questions applied to a small job, as it might appear in GitLab. AI does the work inside the agreed limits; an engineer decides.

!214 · payments/retry-client Draft

Draft: Add a timeout test for the retry client

  1. The task

    A missing timeout test

    Issue #482: the retry client has tests for success and the retry limit, but nothing checks what happens when a request times out.

    Owner Priya Shah · Assigned to AI assistant

  2. Agreed access

    One repository, limited permissions

    • Read payments/retry-client
    • Push to its own branch, ai/timeout-test
    • Run the test suite and open a draft merge request
    • No merging, no changes to main
    • No CI/CD variables, secrets or production data
  3. Evidence

    Draft merge request with test results

    Pipeline #8812
    Passed
    Unit tests
    49 passed, 1 new
    Fails without the fix
    Confirmed
    Security scan
    No new findings
    Changes
    1 test file, +31 lines

    AI note: “The test simulates a slow server and checks the client stops after 5 seconds and retries twice.”

  4. Human decision

    Priya Shah reviews and decides

    Priya, the senior engineer who owns the service, reads the diff, checks the timeout value matches the service setting and confirms nothing else changed.

    Priya Shah Approved and merged

    Merge rights: named engineers only. The AI assistant cannot approve or merge.

Illustrative example The engineer, repository, issue and results are invented to show the workflow. Not customer work.

Start here

Find out where AI can help, safely.

A Health Check is a paid, expert-led review of your GitLab platform, delivery workflow and AI use. You get findings and a prioritised roadmap. Scope, timing and cost are agreed before work starts.