START HERE

What you will learn

  • Choose a hosting and autonomy boundary suited to an initial pilot.
  • Define measurable success criteria without presenting targets as results.
  • Sequence a minimal implementation before adding platform complexity.

Before you start: A repository with repeatable checks, an owner who can accept changes, and ten existing low-risk tasks suitable for a trial.

Reference edition: Provider-neutral reference design; named tools are implementation examples. Sources checked 2026-11-12.

Prove a vertical slice before building a platform

The first milestone is one complete journey: receive a structured task, prepare an isolated checkout, run the engine, validate the candidate, open a change request and return an evidence link to the source task. A dispatcher, disposable worker image, repository instructions, trusted validation/publishing integration and durable status record are enough to test this.

Begin with reviewed contracts and one worker. Add a durable queue, leases, idempotency and stronger cancellation before enabling unattended queued retries or concurrency. A visual workflow designer, agent conversation platform, vector database or heavyweight planner is not required to prove that a bounded bug fix can reach review.

Choose the runtime by operational needs

A dedicated Linux VM running isolated containers is a reasonable initial option when concurrency is low and someone owns patching, capacity, recovery and monitoring. Persistent storage can simplify setup, but each run still needs its own clean workspace and credential lifecycle. Treat the VM as production infrastructure even when the changes it proposes are only for review.

Managed container jobs become attractive when per-task scheduling, stronger workload separation or variable concurrency justify the extra networking, image, identity and observability configuration. Lightsail and ECS Fargate are examples of these hosting approaches, not required services. Keep workspace setup, artifacts and engine configuration portable; do not base central unattended operations on a personal workstation staying online.

Increase authority one gate at a time

A practical autonomy ladder is analysis, development, integration, staging and production. Analysis investigates code. Development edits a bounded workspace and runs checks. Integration publishes a branch and change request through a controlled identity. Staging introduces release effects and therefore needs additional deployment gates. Production needs explicit ownership and release policy.

For the pilot, aim for integration: a reviewable proposal with checks, not automatic production delivery. Keep destructive actions, sensitive data access and risky schema changes behind explicit authorisation. The levels are a planning model for this design, not an industry certification or a promise that every task at a level has equal risk.

Measure task outcomes and human effort together

Select ten existing tasks with known expected behaviour and keep that cohort visible. Record eligibility, exclusions, engine/profile version, runtime, cost, interventions, validation artifacts, reviewer effort, accepted outcome and any policy deviation. Compare with the manual baseline where one is available. A fast proposal that creates more review and repair work may be a poor result.

The targets below are proposed pilot goals, not measured benchmarks. With ten tasks, each task changes a percentage by ten points. “Under 20% rescue” therefore means at most one rescued task. Define intervention and rescue before starting so that routine review is not counted inconsistently and hidden operator work cannot inflate the unattended completion figure.

Planning and implementation need different evidence

An execution worker implements a bounded contract. A planning agent proposes scope, dependencies, assumptions and a sequence of tasks. Planning can change what the organisation decides to build, so keep it human-supervised initially. Decomposition that looks plausible can still miss a shared dependency or an access constraint.

After execution is reliable, test planning on a narrow, low-risk class of request. Require a person to approve the resulting contracts before they enter the execution queue. More agents are useful only when they address a measured bottleneck; they also add coordination, identity and failure modes.

Decide what earns the next phase

Phase one establishes the end-to-end worker, known test profile, structured logs and terminal states. Phase two adds durable scheduling, duplicate-safe recovery, source-system adapters, a dashboard and cancellation. Phase three adds bounded remediation, independent CI enforcement, controlled staging delivery and concurrency limits.

Move between phases using evidence. If many tasks need scope clarification, improve intake before buying more execution capacity. If accepted changes are good but queues are slow, investigate capacity. If tests are weak, improve validation before increasing release authority. Stop or narrow the pilot after a policy violation; do not average an unauthorised release into an otherwise attractive completion rate.

Proposed goals for a ten-task pilot

MetricDefinitionProposed goal
Unattended completionTask reaches Review without an operator repairing its execution or scopeAt least 7 of 10
Valid change requestsReviewer confirms the proposal meets the agreed functional and quality criteriaAt least 8 of 10
Manual rescueA person takes over implementation or repairs a failed run to obtain an outcomeAt most 1 of 10
Unapproved production releasesProduction effects outside the release policyZero
Execution visibilityEvery attempted task has a terminal or current state, owner and evidence references10 of 10
Traceable runsLogs and artifacts identify the input revision, profiles, checks and result10 of 10; inspectability, not identical model output

Step-by-step process

  1. Select and freeze the cohort

    Choose ten low-risk tasks with acceptance examples. Record exclusions and keep failed or blocked attempts in the denominator.

  2. Set the release and runtime boundary

    Choose a single-worker runtime and integration-only authority. Assign owners for credentials, infrastructure, acceptance and incident recovery.

  3. Run and record consistently

    Use the same definitions for intervention, rescue and valid change requests. Capture cost and review time as well as pass/fail.

  4. Review failures before expansion

    Separate ambiguous scope, engine limitations, broken infrastructure and inadequate tests. Choose the next phase based on the dominant constraint.

FOLLOW ONE EXAMPLE

Worked scenario

A plausible pilot result that is not yet an expansion decision

In a hypothetical ten-task trial, seven tasks reach review without intervention, eight proposals meet the reviewer’s criteria, one needs manual rescue and none affects production.

  1. The owner records that these figures meet the proposed numerical goals, while retaining all ten task records and the definition of each measure.
  2. They inspect review effort, cost and the failed tasks. Two proposals consumed disproportionate reviewer time because the original contracts left API compatibility ambiguous.
  3. Before increasing concurrency, they strengthen those acceptance criteria and repeat a comparable trial. Automatic production release remains out of scope.

What this shows: The pilot supports a specific next improvement, not a claim of proven organisation-wide productivity. These figures are illustrative and are not Mint Bios performance results.

The process at a glance

The pilot earns additional capacity or authority through recorded outcomes. A failed gate leads to a targeted improvement before another trial, not an automatic increase in autonomy.
ProcessDecisionHuman checkpoint
Read Mermaid diagram source
flowchart TD
 A[Ten eligible tasks and baseline] --> B[One worker and reviewed contracts]
 B --> C[Checked change requests]
 C --> R[Human review and recorded outcomes]
 R --> D{Boundaries and goals met}
 D -->|No| E[Improve scope controls or validation]
 E --> B
 D -->|Yes| F[Add durable scheduling and recovery]
 F --> G[Evaluate concurrency and staging gates]
 G --> H[Separate production authorisation]

What you should have at the end

  • A ten-task cohort with definitions, baselines and proposed targets clearly separated from results.
  • A phased implementation plan ending each stage with an evidence-based decision.

Common mistakes and how to avoid them

Using a small pilot as a productivity benchmark

Ten tasks reveal operational issues but cannot establish a general success rate across repositories and task types. State the cohort and limitations.

Counting PR creation as accepted value

Measure whether the proposal meets the criteria and what it costs a reviewer to assess it.

Scaling before recovery works

Duplicate-safe publication, cancellation and workspace cleanup should be demonstrated before parallel unattended work.

Adding planning agents to solve vague intake

First make the task contract and approval process work. Planning suggestions still need scope and authority checks.

APPLY THE IDEA

Try it yourself

Your task: Choose ten existing tasks and define the acceptance, intervention and rescue measures before any worker runs.

What to produce: A pilot register with a fixed denominator, proposed goals, release boundary and one explicit stop condition.

Check your understanding: Would a failed or blocked task remain visible, and could another reviewer calculate the same metrics from your records?

Key terms in plain English

Vertical slice
One complete journey through intake, execution, validation and handoff.
Pilot cohort
The fixed set of tasks used to evaluate the initial design.
Manual rescue
A defined human takeover or repair required to obtain an outcome.
Release gate
A condition and authority check required before a deployment can proceed.

Sources and further reading