Introducing Flotilla

Why we built it

SagentLab's premise has always been AI-agent engineering with enterprise-grade delivery. For the past year, that has meant running a portfolio of projects in which AI agent sessions do most of the building: planning tasks, writing code, reviewing pull requests, running QA.

The surprise was where the bottlenecks turned out to be. They were not in code generation. Agents write competent code, and they do it around the clock. The constraints that actually limited how many projects one person could run were older and more human.

Visibility. When a dozen sessions work overnight across several repositories, "what happened?" becomes a hard question. Scrolling terminal logs does not answer it. Neither does a stack of unread pull requests.

Trust. Reading every diff does not scale. But merging work you have not verified is not engineering — it is hoping. We needed a way to judge work without redoing it.

Steering. Priorities shift weekly, sometimes daily. Without a deliberate channel for guidance, the human becomes a full-time dispatcher, which defeats the point of autonomous crews.

We built internal tooling to fix those three problems for our own client work. The tooling grew into a platform. That platform is Flotilla, and we are opening it for early access.

What it is

Flotilla lets one person command a fleet of AI engineering crews. Crews plan, build, review, QA, and ship real software across a portfolio of projects. The human steers: sets direction, approves the gates that matter, and watches everything on the record.

Five commitments define the platform.

Autonomous delivery, human command. Crews carry the work from plan to production. You are in the loop exactly where it counts: setting priorities, giving guidance when direction changes, and approving the gates that matter — production deploys, budgets, scope. Everything else runs without you.

Everything on the record. Every task, PR, decision, and deploy lands in an append-only activity ledger with links to its evidence. Every PR ships with before/after screenshots, and with a video walkthrough of the changed flow where recording is possible. You judge work from evidence, not from status updates.

Your code stays yours. Flotilla is GitHub-native. Repositories live in your organization, work arrives as normal pull requests, and project knowledge lives in markdown you can take anywhere. The platform stores links and summaries, never copies. If you leave, everything of value leaves with you.

Quality engineered in. Every PR gets an independent AI review — the reviewer is never the author. End-to-end QA gates run full user journeys before anything ships. And autonomy is earned: a project gets more of it only when its measured quality supports it.

Idea to production, and beyond. New projects spin up on best-practice stacks — Next.js, Vercel, and Supabase for web applications; GCP for data pipelines. Work ships through gated CI to real environments. After launch, the same crews keep maintaining the product: dependencies, security updates, small features.

How it works

The unit of everything is a loop, and every piece of work moves through the same one.

It starts with direction. Priorities, constraints, and budgets live in steering documents that you own. Crews consult them at the start of every session, so course corrections propagate without a meeting.

A dispatcher routes planned tasks to agent sessions across your projects. Each session receives the task, the project's accumulated knowledge, and only the credentials that specific task needs — a session building a feature never holds production secrets.

Work comes back as pull requests that carry their own proof. A user-visible change arrives with before/after screenshots and a recorded walkthrough of the flow. A backend change arrives with the equivalent: test output, API responses, timing comparisons. Most PRs can be judged from the evidence alone.

Then the work is challenged. A separate session — never the one that wrote the code — checks out the PR and files a real code review: inline comments, requested changes, or approval. Requested changes spawn follow-up work automatically. Before a milestone closes, QA sessions run end-to-end journeys against a preview deployment, and nothing ships until that gate passes.

You approve, and it ships. Production deploys sit behind gates only a human can open. Merged work flows through CI to preview, staging, and production.

And all of it lands on the record. Every step writes to the ledger with evidence attached, so any shipped artifact can be traced back to the task, the review, the QA run, and the approval that produced it.

Why you can trust the output

Two principles, applied without exception.

The first is evidence over promises. Nothing in Flotilla is "done" because an agent said so. Done means the PR exists, the evidence is attached, the independent review passed, and the QA gate is green. The ledger holds the receipts.

The second is that autonomy is earned. Every project is measured on the quality of its loop: how often work gets reworked, how often reviews reject, how often bugs escape QA. Strong numbers earn a project more autonomy — less waiting on you for routine changes. Weak numbers pull autonomy back. The dial moves on measurement, not on optimism.

What's next

Flotilla is in development, and we are onboarding a small number of early-access teams. We work closely with each one — connecting existing repositories or starting new projects — and we shape the roadmap around what they actually ship.

If you are a founder who wants software delivered without building a large team, or an engineering leader running more projects than you can watch, we would like to hear what you want to ship.

Request early access, or read more about what Flotilla stands on.