Plan with purpose
Agents turn ambitious goals into clear, actionable plans.
- Decompose complex problems
- Prioritise what matters
- Adapt plans as context changes
Autonomous by design
Self-directing agents plan, build, review, and ship software end-to-end — running a complete agile process continuously, at scale.
Plan
Set goals and break down work.
Build
Write, test, and iterate.
Review
Check quality and refine.
Ship
Deploy and monitor impact.
Plan → Build → Review → Ship → Continuously improve
From idea to impact, ForgeLoop’s agents work together to deliver software continuously.
Agents turn ambitious goals into clear, actionable plans.
Specialised agents implement, test, and iterate autonomously.
Peer review and deployment are built into the process.
Guardrails
Review effort scales with risk — light touch for low-impact changes, rigorous multi-stage checks and human sign-off for critical paths.
Docs and tests
Quick diff review plus the CI gate.
Product code
Standards review, spec and acceptance review, about 1 in 5 spot-checked by a human.
Money, auth, deploy, review policy
Everything in T2, then a human signs off on that exact commit.
Code standards and spec acceptance are evaluated as independent review streams.
Reviewers have read-only permissions — they critique and verify without altering branch code.
High-impact tasks require an approved plan and architecture breakdown before implementation.
Review findings and post-merge insights are codified back into repo guidance after every merge.
Telemetry
Performance metrics generated directly from our autonomous delivery pipeline. Real figures, updated monthly, fully transparent.
* Partial week
Resolved and verified in a 30-day window
Approved on initial review
Average review iterations
Model inference spend
Two-axis consensus rate
98% written by agents · 59% tests
The team
Senior Engineer
Claude Opus 5.5
Architecture, complex features, and reviews teammates' pull requests.
Senior Engineer
Gemini 3.8 Flash
Features and code review.
Junior Engineer
Claude Haiku 5.5
Bug fixes, DevOps, and smaller tasks.
Junior Engineer
DeepSeek V4 Flash
Bug fixes, DevOps, and smaller tasks.
Site Reliability Engineer
Will monitor live systems.
Open headcount
Reserved seatProcess
Every project moves through a nine-stage agile pipeline — from idea to continuous learning.
A new problem, feature proposal, or refinement lands in the backlog.
Stakeholders or agents identify a product gap, system improvement, or bug. The idea is captured in an issue tracker with context on the problem and why it matters.
Manager or team member
Issue tracker, problem framing, and discussion threads.
Code repositories, sprint commitments, or deployment configurations.
Scope, user impact, acceptance criteria, and constraints are defined.
The backlog item is shaped into a crisp project brief. The team establishes explicit scope boundaries, non-goals, testable acceptance criteria, and initial risk assessment.
Manager or senior agent
Specification documents, acceptance criteria, and requirement definitions.
Implementation code, working branches, or production schedules.
Tickets are sized, dependencies mapped, and sprint goals locked.
The team reviews candidate briefs, verifies prerequisites, sizes tasks, checks risk classifications, and commits to a focused batch of work for the sprint cycle.
Full team and manager
Sprint board, ticket estimates, and milestone assignments.
In-progress branch code, production releases, or review policies.
Senior agent architects the solution before code is written.
For senior-tier or architecturally significant work, an agent writes a structured implementation plan. The plan maps public interfaces, safety rails, file changes, and verification strategies before any code changes begin.
Senior agent (reviewed by manager for one-way doors)
Design documents, architecture breakdowns, interface contracts, and plan files.
Production codebase, package dependencies, and deployment infrastructure.
Autonomous implementation with tests against the plan.
The assigned agent implements the solution in a dedicated branch, writing clean code, adhering to repository conventions, and creating automated tests that verify each acceptance requirement.
Assigned implementation agent
Feature branch code, unit tests, integration tests, and component stories.
Main branch, CI configurations, deployment pipelines, and unassigned issues.
Independent two-axis review of code standards and spec acceptance.
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.
Independent senior reviewer (read-only)
Pull request comments, review verdicts, audit notes, and suggested diffs.
Branch commits, merged history, and direct code alterations.
Dual independent review streams evaluate code quality and requirement satisfaction.
Rejected on risk limit boundary check. Branch cannot merge until negative boundary enforcement and corresponding regression tests are added.
Human sign-off on the exact commit for critical paths.
For critical-tier work (such as deployments, authentication, risk limits, or review policy changes), the manager inspects the verified pull request and provides explicit human sign-off on the exact commit hash before merge is permitted.
Manager (human stakeholder)
Sign-off approval record, release authorization, and audit trail.
Branch source code (must verify the exact audited commit without modification).
Automated gate check and squash merge to the main branch.
Once all review axes pass and required sign-offs are in place, the dispatcher verifies the CI suite one final time against HEAD and completes an atomic merge into the main branch.
Dispatcher (automated merge runner)
Main branch commit history, pull request closure, and deployment trigger.
Code content (cannot introduce modifications during merge).
Post-merge review insights codified back into repo guidance.
Following every merge, review findings, unexpected edge cases, and architectural learnings are extracted and written back into repository documentation and agent prompt instructions so future runs never repeat the same mistake.
Agent retro reviewer and manager
Repository guidance, rulebooks, team docs, and agent prompt instructions.
Production systems, past release tags, and historical commits.
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.
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.