Agent Development Lifecycle

ADLC: the Agent Development Lifecycle.

ADLC, the Agent Development Lifecycle, is how Ferrata Labs builds, tests, governs and runs AI agents in production. It starts with one foundation: Anchor, setting up your Brain behind your firewall. Then every agent goes round the same seven-phase loop, from Scope to earned autonomy, and the next agent starts on the same foundation.

Your environment · behind your firewall01AssessThe queue, in orderInvoice matchCollectionsBank recOrder entry03First agent · the first pass, gatedNext agent01Scope02Build03Evaluate04Gate05Deploy06Observe07ImproveThe loopOnce per agentScope to earned autonomyApprovalgateAcross your organizationAgent 1 · LiveAccounts payableAgent 2CollectionsAgent 3ReconciliationNext passOrder entry04AI nativeYour team runs the loopBuilt on one foundation02Anchor · laid onceYour BrainYour data and rules, inside your environmentSystems of recordOpen-weight models, trained insideEvaluationAuditIdentityFrontier modelsOnly work with noneof your data
  1. 01AssessDecides which agents go round the loop, and in what order.
  2. 02AnchorLays the foundation once: your Brain, behind your firewall.
  3. 03First agentThe first trip round the loop, led by our AI Velocity POD, gated.
  4. 04AI nativeYour team runs the loop itself, agent after agent.

SDLC was built for code. ADLC is built for agents.

Software got reliable when teams stopped treating each build as a one-off and adopted a lifecycle around it. Agents are at the same point, but code and agents fail differently. Code does what it was written to do; an agent makes a judgment on live work. The lifecycle has to change with it.

SDLC · built for codeA line that ends at releaseRequirementsDesignBuildTestReleaseTests pass or fail. Done when it ships.Fixes come after, as bugs.ADLC · built for agentsA foundation, then a loopScopeBuildEvaluateGateImproveObserveDeployNext agent ↺Anchor · your Brain, laid onceBehind your firewallScored on your real cases. Gated, then autonomy earned.
SDLCADLC
What you buildCode with defined behaviorAgents that make decisions on live work
How you know it worksTests that pass or failA score against your real history, the awkward cases included
ReleaseShip, then patchGated first; autonomy earned one class of action at a time
What goes wrongBugsDrift, a wrong judgment, data in the wrong place
FeedbackBug reports and postmortemsEvery override, examined and fed back
DataTest fixturesYour systems of record, governed, behind your firewall
ShapeA line, from requirements to releaseA foundation laid once, then a loop for every agent

The foundation

Anchor: setting up your Brain

Before the first agent, we anchor the intelligence it will run on inside your environment. Your systems of record, your documents and your rules become one Brain behind your firewall. Every agent after the first is built on it, which is why the second agent takes weeks rather than months.

Systems of record

SAP, NetSuite or Dynamics, plus the mailboxes, spreadsheets and documents the work actually runs on. No demo data.

Open-weight models, trained inside

Fine-tuned on your data inside your firewall, for your workflows only. The model it produces is yours.

Frontier, only without your data

Frontier models are used only for work that carries none of your data. Your data never reaches a frontier lab.

Evaluation

The harness that every agent will be scored against, built from your real historical cases.

Audit

Every action, its evidence, its approver and its timestamp, written for an auditor to read.

Identity

Agents authenticate as themselves against your directory and reach only what their scopes allow.

Done when
The Brain answers from your systems of record, inside your environment, under your identity.
You keep
The Brain, its connections, and the access controls around it.

The loop

The loop, phase by phase.

Seven phases, once per agent. Each one has an exit condition, so a phase is finished when its evidence says so rather than when the calendar does, and each leaves something your team keeps.

  1. 01

    Scope

    One workflow, stated as a contract: the inputs, the decision boundary, what the agent may never do, and the number it is measured on.

    Done when
    The process owner signs the contract, with a baseline measured.
    You keep
    The workflow contract

  2. 02

    Build

    Tools, prompts, routing and fallbacks, wired to your systems through the Brain. Anything that touches your data runs on open-weight models inside your firewall; frontier models only see work that carries none of it.

    Done when
    The agent runs end to end on real historical inputs, outside production.
    You keep
    The agent, its prompts and tool definitions

  3. 03

    Evaluate

    A harness of your real historical cases with known-correct outcomes, the awkward ones included. The agent is scored against them, not demonstrated on a happy path.

    Done when
    Accuracy clears the threshold agreed in Scope, on the full harness.
    You keep
    The evaluation harness

  4. 04

    Gate

    Every consequential action routes to a person for approval, and the rollback path is defined, before go-live rather than after an incident.

    Done when
    The approval queue, its owners and the rollback are tested end to end.
    You keep
    Gate rules and the rollback runbook

  5. 05

    Deploy

    Into your environment, against live transactions, at a volume you choose. Logged and attributable from the first action.

    Done when
    Live on real transactions, with every action in the audit log.
    You keep
    The audit log

  6. 06

    Observe

    Accuracy, exception rate, cost per transaction and gate overrides, tracked continuously. Drift is caught by the harness, not by a person noticing.

    Done when
    Dashboards and alerts are owned by a named person on your side.
    You keep
    Monitoring and alerts

  7. 07

    Improve

    Every override is examined and fed back. Gates come off one class of action at a time, when the evidence and you say so, and go back on if a signal drifts.

    Done when
    Each gate removed has a recorded reason and the evidence behind it.
    You keep
    The autonomy record

  8. ↺

    Next agent

    Back to Scope for the next workflow in the queue, on the same foundation. Each pass is faster than the last, because the Brain, the harness and the gate rules are already there.

Each trip round the loop is one use case: AI agent use cases in finance and operations →

Gated first. Autonomous once it has earned it.

Every agent stops at an approval gate until it has earned its way out of one. Nothing releases cash, commits spend or touches a customer without a person saying so. Autonomy is something the evidence and you grant, one class of action at a time, and it can be taken back.

Phase one · gatedAgent draftsA personapprovesPostedOverrides teach the agentYour call · on evidenceAccuracyThreshold agreed in ScopeWeeks live · illustrativePhase two · earnedAgent actsOne class of actionPostedExceptions to a personA signal drifts: the gate goes back on

Phase one

Gated

A person approves every consequential action. Approvals and overrides are recorded, and each override teaches the agent.

Your call

Evidence

Accuracy on the harness and in production clears the threshold agreed in Scope, and you are comfortable. Then one gate comes off.

Phase two

Earned

The agent executes that class of action on its own. Exceptions still go to a person, and every action is still logged.

If accuracy, exception rate or cost drifts, the gate goes back on until the evidence returns.

AI agent governance, built into every phase.

AI agent governance is the set of controls that decide what an agent can reach, what it may do on its own, and how every action is evidenced. In the ADLC each control has a home phase, so governance is part of the build rather than a review after it.

  1. FoundationData stays inside your firewall
  2. 01 ScopeDecision boundary
  3. 02 BuildModel and data policy
  4. 03 EvaluateEvaluation evidence
  5. 04 GateApproval gate and rollback
  6. 05 DeployAttributable log
  7. 06 ObserveMonitoring
  8. 07 ImproveAutonomy on evidence

How we set up ADLC in your enterprise.

The goal is that your team runs the loop without us. Our AI Velocity POD, two forward-deployed engineers backed by Ferrata Labs architecture review and validation, works inside your business and IT teams, and hands the loop over one pass at a time.

  1. Loop 1

    We lead

    The AI Velocity POD runs every phase on your first agent. Your people sit in on each one.

    Ferrata LabsYour team

  2. Loop 2

    You pair

    Your engineers take Build and Evaluate, with ours alongside. Gate and Deploy stay shared.

    Ferrata LabsYour team

  3. Loop 3

    You lead

    Your team runs the loop. We review the architecture and validate the release.

    Ferrata LabsYour team

  4. Then

    You run it

    No Ferrata Labs on the critical path. You should never need us to change a prompt.

    Ferrata LabsYour team

What stays installed, and is yours

  • The Brain, its connections and access controls
  • Evaluation harnesses for every agent
  • The approval queue and gate rules
  • Runbooks for deploy, rollback and drift
  • Workflow contracts and agent templates
  • Monitoring, alerts and the autonomy record

The engagement around this is set out on how it works, and the team that runs it on the AI Velocity POD.

Questions we get asked about ADLC.

What does ADLC stand for?
ADLC stands for Agent Development Lifecycle: the discipline for building, testing, governing and running AI agents in production. At Ferrata Labs it is one foundation, Anchor, which sets up your Brain behind your firewall, and then a seven-phase loop every agent goes round: Scope, Build, Evaluate, Gate, Deploy, Observe and Improve.
Does ADLC replace the four stages of an engagement?
No. The four stages are how we take you through it. Assess decides which agents go round the loop and in what order, Anchor lays the foundation, your first agent is the first trip round the loop, and in stage four your own team runs the loop. The stages are what you buy; ADLC is the framework underneath them.
Who runs the ADLC at Ferrata Labs?
Our AI Velocity POD: two forward-deployed engineers who learn your business, sit with your business teams and work alongside your IT team, with Ferrata Labs architecture review and validation behind every release. They run the first loop, then hand it to your team one pass at a time.
What is AI agent governance in the ADLC?
The controls that decide what an agent can reach, what it may do on its own and how every action is evidenced. Each has a home phase: the decision boundary in Scope, the model and data policy in Build, evaluation evidence in Evaluate, the approval gate in Gate, the audit log in Deploy, monitoring in Observe and autonomy on evidence in Improve.
When does an agent get more autonomy?
Only on evidence, and only when you are comfortable. Every agent starts with a person approving each consequential action. When accuracy clears the threshold agreed in Scope, one class of action comes out of the gate at a time. Exceptions still go to people, and the gate goes back on if a signal drifts.
Can our own team run the ADLC without Ferrata Labs?
That is the point of it. We lead the first loop, your engineers pair on the second, your team leads the third with our review, and after that you run it. The Brain, the harnesses, the gate rules and the runbooks stay installed in your environment and are yours.

Your agents are built around your organization.

The way you price, route, approve and escalate is years of accumulated judgment, and it's a real advantage. It belongs to you and it stays with you, we're not asking you to hand over your playbook or fit yourself into someone else's template. We start from how your business already works, encode that logic into agents built for your environment, and leave you with an operation that runs faster with exactly the things that make you good at it still intact.

Bring us one workflow.

Thirty minutes, no deck. Pick the process that costs you most in people, errors or delay, and we'll pressure-test whether an agent is genuinely the right answer for it.

  • An honest read on whether that workflow is a good agent candidate
  • What the first deployment would involve, and roughly what it costs
  • An honest answer if the sequencing is wrong and you should fix something else first
Book a discovery call