Skip to content
Let’s talk

Closed-loop development

Close the development loop.

Coordinate coding agents, follow changes through PR review and carry findings into the next task.

Backloop Dev keeps work, context and evidence connected, within explicit policies and human-defined authority.

See how it works Start a conversation
Governed execution / System schematic
Human / Architect intent ↓

Governor coordinates execution

Daemon / Hard boundaryEligible to run?

Dependencies · conflicts · capacity · active work

Hold / resolve constraintDispatch ↓
Task ↔ coding sessionPersistent ownership
PR + CI + review ↳ Feedback to the owning worker

Coding is becoming autonomous.
Development isn’t.

Autonomy without feedback is just automation.

Coding agents implement tasks. Development still needs coordination: deciding what can run, preserving context, checking outcomes and feeding findings into the next change.

  1. Coordinate work
  2. Check outcomes
  3. Feed lessons back

Execution / Active Work

See what’s moving—and what needs you.

Active Work brings Automated tasks and Coding sessions into one operational view without losing task ownership or parent/helper context. Building, validating, in review and ready show what can move next—and when a person needs to decide.

Active Work: tasks grouped by execution state, with parent/helper context.Illustrative project data · Backloop Dev desktop app
  1. 01Plan
  2. 02Govern
  3. 03Build
  4. 04Review
  5. 05Verify
  6. 06Adapt

A development model. Outcome verification and adaptive planning remain boundaries being connected.

Control

Decide what should run before another agent starts.

Backloop Dev maintains a live model of development work across issue state, dependencies, active workers, pull requests, CI, reviews, conflicts and available capacity.

Architect can plan or explicitly direct work on the user’s behalf. Governor coordinates what runs next, chooses the execution profile and reconciles current project state. Within their assigned authority, agents can coordinate, review and approve work. The daemon enforces dependencies, conflicts, duplicate ownership, capacity and hard policy boundaries deterministically; people retain designated decisions.

01Eligibility
Issue state determines whether work can enter the queue.
02Dependencies
Prerequisite work can hold a task back.
03Conflicts
Overlapping development surfaces constrain concurrent work.
04Capacity
Worker limits and cooldowns constrain dispatch.
05Active work
Existing sessions and PRs prevent duplicate execution.
06Human gates
Supervised work stays visible for operator judgment.
Task chat: a draft-scoping investigation and the next validation step.Illustrative project data · Backloop Dev desktop app

Execution / Chat

Keep progress, blockers and handoffs with the work.

The task conversation records the user’s intent, the agent’s investigation and the decision that should happen next. That makes coordination reviewable instead of turning it into disconnected status chatter.

Illustrative project data is read-only: saved context is available while dispatch, model calls and other execution side effects stay disabled.

Coding sessions

Give every change a focused working context.

A coding session keeps the intent, investigation, current state and next decision together with the change. It can originate from coordinated execution or the user-led Coding sessions shortcut.

The task remains the owner; helpers retain their parent relationship instead of becoming duplicate project nodes. That makes the implementation conversation inspectable without creating a second navigation destination.

Saved context survives controller restarts. Live execution remains bounded by the configured policy and operator authority.

Coding session: implementation context kept with the owning task.Illustrative project data · Backloop Dev desktop app
PR Review: a scoped learning and the corrective review record.Illustrative project data · Backloop Dev desktop app

Review

Keep feedback connected to the change.

Findings, a correction and regression evidence remain linked to the task and its review history. A review result can influence what happens next, but it never removes the operator’s authority to decide.

Supported reviewer workflows can offer scoped learnings while the daemon maintains deterministic ownership, capacity and policy boundaries.

↳ A finding is an input to the next decision.

Learnings

Carry review lessons into the next change.

Review findings can become durable, scoped learnings. Backloop tracks where they apply, how often they are reused, and whether findings based on them are later confirmed or rejected — so useful review knowledge survives the session that discovered it.

This review memory carries the outcome of one development cycle into the next: what to check, which boundaries to preserve and what evidence a correction needs.

The output isn’t the end. It’s the next input.

Learnings: project and global scope, reuse counts and review provenance.Illustrative project data · Backloop Dev desktop app

From healing toward self-building

Output becomes the next input.

Self-healing is a loop, not a repair script.

Recovery starts with an observed failure. In the long-term self-building direction, the same loop starts with a desired capability. In both, evidence must inform what happens next.

Shared loop / Development modelNot fully implemented end to end today
RecoveryObserved failure
Self-building / Long-term directionDesired capability
  1. 01PlanBound the work
  2. 02ExecuteImplement a change
  3. 03PR reviewInspect the change
  4. 04VerifyTest the outcome
  5. 05ObserveRead system evidence

Verification + outcome evidence inform the next decision

After merge, where relevantPost-merge QA and release/deployment use configured workflows. Merge is not deployment; passing PR review is not proof of the product outcome.

Current capability

What is closed today.

Available / Execution · Learnings
Supported task-to-PR-review flows preserve ownership, CI and review evidence. Scoped learnings inform future work; they are not a mandatory gate.
Being connected / Architect · QA · Release · Health
Planning and Health remain in development. Post-merge QA and configured release workflows are distinct from PR Review; full production outcome verification is not closed end to end.
Long-term direction / Self-building
Fully autonomous recovery and completion of arbitrary high-level goals are not current capabilities.

Backloop Dev

Give your software a development loop.

Backloop Dev connects engineering intent, execution, review and feedback into one controlled system.

Start a conversation hello@backloop.si← Back to Backloop