START HERE

What you will learn

  • Separate orchestration responsibilities from model-generated implementation.
  • Map a provider-neutral path from intake to a reviewed change.
  • Identify which decisions belong outside an execution agent.

Before you start: You can describe how a development request reaches your repository today. No particular project-management tool, coding assistant or cloud provider is required.

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

The useful unit of autonomy is a bounded change

Imagine a request to fix a search filter. An autonomous worker receives a precise description, changes code in a disposable checkout, runs agreed checks and submits a change request. That is a useful unit of work because its outcome can be inspected. “Improve our application” has no equivalent stopping point.

Autonomy here means the worker can complete authorised steps without a person answering terminal prompts. It does not mean the worker can expand its permissions, merge its own changes or release to customers. When a required action is outside the approved boundary, the correct outcome is a recorded block.

Your control service owns the decision trail

The control service accepts requests, resolves the repository and base revision, checks authority, creates an execution record and dispatches work. It owns state transitions, cancellation, budgets, permissions and the evidence needed to explain an outcome. A Node.js service is one implementation; those responsibilities can also sit in another suitable backend.

The execution engine proposes edits and reports observations. It must not be the sole authority on whether its own work passed, whether a user authorised a release or whether a task should be marked accepted. An engine process exiting successfully is an execution event, not proof that the product requirement was met.

Use adapters where external systems meet the workflow

An intake adapter translates a project-management ticket, issue, dashboard request or redacted application error into the same internal contract. A repository adapter manages checkout references and change-request identifiers. An execution adapter maps an approved task to a particular coding engine, its arguments, event format and result. A queue adapter handles delivery and acknowledgements.

Keep vendor identifiers at these boundaries. The internal record can store source.system, source.record_id and source.url without naming a particular project tool in its lifecycle. Likewise, a change request can be a pull request or merge request. Choose the engine by the ability to satisfy the task, data policy and validation contract, rather than embedding its name into every workflow state.

Replaceable does not mean identical

Two coding assistants may expose different tools, sandbox policies, event types and authentication methods. An LLM endpoint on its own is not a development execution engine: something still has to manage file edits, tools and the workspace. Define the minimum capabilities your adapter requires and reject an engine that cannot enforce the chosen execution policy.

Record engine and model versions, configuration, dependency lockfiles and the base commit with each run. Re-test the adapter when any of these change. A consistent interface makes replacement manageable; it cannot guarantee equal quality, cost or behaviour.

Make the trust boundaries visible

The worker should receive an isolated checkout, project instructions, a reviewed task contract, safe fixtures and a short-lived workspace. The surrounding platform constrains filesystem mounts, network destinations, resource use and credentials. Repository text, tickets and error traces are untrusted input; instructions inside them must not override platform policy.

For application-generated bugs, the intake service should redact and minimise stack traces, identify the component and environment, group repeat errors and classify the issue before creating a task. An error report is evidence to investigate, not automatic permission to change a repository. Never forward raw customer payloads, session tokens or credentials into the agent prompt.

Keep source-control publication and production release authority outside the coding sandbox. A trusted publisher can open a change request after validation using a narrowly scoped identity. Independent CI then evaluates the exact submitted revision. A named owner decides acceptance, and a separate release process governs deployment.

Stable responsibilities, replaceable implementations

BoundaryResponsibilityPossible implementationEvidence retained
IntakeNormalise and authorise a requestProject tool, issue tracker or internal formOriginal reference and approved scope
Control serviceOwn lifecycle, budgets and permissionsExisting backend or dedicated serviceExecution ID and state history
Execution engineImplement a bounded taskCodex CLI or another coding agentEngine version, events and patch
Repository and CIPublish and independently check a changeYour source-control and CI platformsCommit, check results and review
Queue and runtimeSchedule and isolate executionDurable queue plus container or managed jobDelivery attempt, lease and runtime record

Step-by-step process

  1. Map one existing change

    Choose a modest bug fix with known behaviour. Write down who approves it, where the code lives, how it is tested and what counts as accepted.

  2. Assign responsibility before selecting products

    Separate intake, policy, durable state, execution, validation, publication and release. Give each responsibility an owner and a failure outcome.

  3. Define narrow adapter contracts

    Specify the input and output of each integration. Preserve external IDs as metadata while using internal task and execution IDs throughout the workflow.

  4. Deliver one vertical slice

    Use one repository, one worker and one coding engine. Produce a checked change request and status update before adding parallel workers or a visual workflow designer.

FOLLOW ONE EXAMPLE

Worked scenario

One search bug, two different tool stacks

An independent developer and a technology leader in a larger organisation both need a postcode-filter fix. Their task trackers, repositories and coding assistants differ; the acceptance criteria are the same.

  1. Both intake adapters produce a contract identifying the approved repository, base commit, expected filter behaviour and prohibited changes.
  2. The control service dispatches an isolated worker through the appropriate execution adapter. Neither task grants production access.
  3. A trusted validator checks filtering and pagination. The publisher creates the appropriate pull or merge request and records its identifier.
  4. The source task receives a link to the checks and change request. Its status is Review, until the agreed acceptance event occurs.

What this shows: The integrations differ while the authority, evidence and meaning of completion remain consistent. This is a reference scenario, not a measured client result.

The process at a glance

The control service governs work and records evidence. The coding engine sits inside a constrained worker; validation, publication and acceptance have separate responsibilities.
ProcessDecisionHuman checkpoint
Read Mermaid diagram source
flowchart TD
 I[Task tracker or redacted bug] --> C[Control service and policy]
 C --> Q[Durable queue]
 Q --> W[Isolated worker]
 W --> E[Replaceable coding engine]
 E --> V[Trusted validation]
 V --> P{Checks pass}
 P -->|No| B[Bounded repair or block]
 B --> W
 P -->|Yes| R[Change request]
 R --> CI[Independent CI]
 CI --> H[Human acceptance]
 C --> S[Durable status and audit record]
 H --> S
 S --> I

What you should have at the end

  • A responsibility map that survives a change of project tool or coding engine.
  • One bounded delivery path ending in a reviewable change, with production authority separated.

Common mistakes and how to avoid them

Making the model the orchestrator

If the model can change its own permissions and completion rules, the task contract cannot constrain the system. Enforce policy outside generated instructions.

Confusing tool neutrality with lowest-common-denominator behaviour

Declare required capabilities, test each adapter and record unsupported operations. Do not silently weaken isolation to accommodate an engine.

Calling the first successful run a platform

First prove the complete change and evidence trail. Add concurrency and integrations only when their operational costs are justified.

APPLY THE IDEA

Try it yourself

Your task: Map the intake-to-review journey for one real repository using roles rather than vendor names.

What to produce: A diagram with seven responsibilities, one owner per boundary and the evidence each boundary emits.

Check your understanding: Could you replace the task tracker or coding engine without changing what Review and Completed mean?

Key terms in plain English

Orchestrator
The service that coordinates work, enforces policy and owns state.
Adapter
A translation layer between a stable internal contract and an external system.
Execution engine
The coding agent and tool runtime used to propose implementation changes.
Change request
A reviewable proposal to merge a particular revision into a repository.

Sources and further reading