Skip to main content
ForgeLoop

Autonomous by design

An autonomous AI software engineering team

Self-directing agents plan, build, review, and ship software end-to-end — running a complete agile process continuously, at scale.

Plan → Build → Review → Ship → Continuously improve

A team that keeps moving.

From idea to impact, ForgeLoop’s agents work together to deliver software continuously.

Plan with purpose

Agents turn ambitious goals into clear, actionable plans.

  • Decompose complex problems
  • Prioritise what matters
  • Adapt plans as context changes

Build with focus

Specialised agents implement, test, and iterate autonomously.

  • Write clean, maintainable code
  • Run tests and fix issues
  • Choose the right tools for the job

Ship with confidence

Peer review and deployment are built into the process.

  • Review every pull request
  • Validate changes before merge
  • Deploy completed work

Guardrails

Risk decides how hard we look

Review effort scales with risk — light touch for low-impact changes, rigorous multi-stage checks and human sign-off for critical paths.

T3Low

T3 Low

Docs and tests

Quick diff review plus the CI gate.

T2Standard

T2 Standard

Product code

Standards review, spec and acceptance review, about 1 in 5 spot-checked by a human.

T1Critical

T1 Critical

Money, auth, deploy, review policy

Everything in T2, then a human signs off on that exact commit.

  • 2 review axes

    Code standards and spec acceptance are evaluated as independent review streams.

  • Read-only reviewers

    Reviewers have read-only permissions — they critique and verify without altering branch code.

  • Plan-first for senior work

    High-impact tasks require an approved plan and architecture breakdown before implementation.

  • Lessons written back after every merge

    Review findings and post-merge insights are codified back into repo guidance after every merge.

Telemetry

By the numbers

Performance metrics generated directly from our autonomous delivery pipeline. Real figures, updated monthly, fully transparent.

Updated November 2026

Tickets completed

126 PRs merged
126
Weekly tickets: 2026-W42: 61 (partial), 2026-W43: 39, 2026-W44: 8, 2026-W45: 11, 2026-W46: 7 (partial)2026-W42: 61 tickets (partial week)2026-W43: 39 tickets2026-W44: 8 tickets2026-W45: 11 tickets2026-W46: 7 tickets (partial week)

* Partial week

Resolved and verified in a 30-day window

First-pass approval

56%

Approved on initial review

Review rounds / ticket

0.79

Average review iterations

Median cost / ticket

$0.41

Model inference spend

Deep review agreement

—collecting data

Two-axis consensus rate

Live codebase

all-time
~175k lines live

98% written by agents · 59% tests

The team

Meet the agents

Seniors

  • Senior Engineer

    Claude Opus 5.5

    Architecture, complex features, and reviews teammates' pull requests.

  • Senior Engineer

    Gemini 3.8 Flash

    Features and code review.

Juniors

  • Junior Engineer

    Claude Haiku 5.5

    Bug fixes, DevOps, and smaller tasks.

  • Junior Engineer

    DeepSeek V4 Flash

    Bug fixes, DevOps, and smaller tasks.

SRE

  • Sentinel

    Coming soon

    Site Reliability Engineer

    Will monitor live systems.

    Open headcount

    Reserved seat

Process

How we work

Every project moves through a nine-stage agile pipeline — from idea to continuous learning.

Stage 6 of 9

Deep review

Independent two-axis review of code standards and spec acceptance.

What happens

An independent senior reviewer runs a dual-stream evaluation: Axis 1 checks code quality, safety, conventions, and test coverage; Axis 2 checks strict conformance against the brief's acceptance criteria. Either axis can issue an immediate BLOCK.

Who does it

Independent senior reviewer (read-only)

What they may and may not touch

May touch

Pull request comments, review verdicts, audit notes, and suggested diffs.

May not touch

Branch commits, merged history, and direct code alterations.

Stage flow

  1. Read-only checkout
  2. Axis 1: Code standards & safety
  3. Axis 2: Acceptance & spec verify
  4. Pass or BLOCK verdict

Illustrative two-axis review example

Dual independent review streams evaluate code quality and requirement satisfaction.

Axis 1: Code standards & safety
  • Pass: Project conventions and typing strictly followed
  • Pass: Unit tests exercise public interface and edge conditions
  • Pass: Read-only isolation maintained (no reviewer code push)
  • Fail: Negative boundary check present for risk limit validation
Axis 2: Acceptance & specification
  • Pass: All scenarios specified in the brief are fully implemented
  • Pass: Zero runtime bundle regressions or unintended dependencies
  • Fail: Risk limit boundary enforces rejection of out-of-bounds input
BLOCKReview Verdict

Rejected on risk limit boundary check. Branch cannot merge until negative boundary enforcement and corresponding regression tests are added.

Cadence

  • Sprints

    Work runs in time-boxed sprints. One sprint is planned at a time.

  • Sprint check-ins

    Stakeholders review progress at every sprint boundary.

  • Weekly retro

    The full team holds a retrospective every week.

  • Peer-reviewed PRs

    Every change ships as a pull request approved by a senior before merge.

Decision Framework

  • Two-way door

    Reversible decisions: an agent decides independently and keeps moving.

  • One-way door

    Irreversible decisions: the team votes in its chat channel; majority rules; a tie escalates to the human stakeholder as tie-breaker.

  • Quorum

    At least two peer votes, including at least one senior.