Open source · Enterprise in private preview

AI-driven SDLC, under strict human governance

Hand it a ticket from whatever tracker you use — or a single line of plain English. It elaborates, asks the clarifying questions, then designs, implements, tests and deploys. From one change to an entire product, through a pipeline you shaped, with a human at every gate and a complete record of who decided what, when and why. Start free in any repo; Enterprise adds an org-wide control plane and governed AI agents.

12phases, run the ones you need
5human gates you can't skip
7AI tools it plugs into
0dependencies to install
One unit of work, end to end

A ticket in. Shipped, audited software out.

You trigger one command. Zyroflo drives the whole lifecycle — and stops for a human at every gate. Here is one ticket, start to finish. The same loop delivers a fix, a feature, a release, or an entire product.

▶
Trigger

You hand it the work

A ticket ID from whatever tracker you run — Jira, Salesforce, StarTeam, Azure DevOps, ServiceNow — or one line of plain English. Zyroflo pulls the item and reads it.

/sdlc PROJ-482
P0
Intake

It elaborates the requirement

Turns a one-liner into a full statement of what is being asked.

00-intake.md
P1
Requirements

It asks the clarifying questions — and waits

Scope, data, errors, performance. Questions first, then testable acceptance criteria.

10-requirements.md
◆ G1 · scope
P3
Design

It designs the change

Options with trade-offs and a recommendation, against your standards.

30-design.md
◆ G2 · design
P4
Implementation

It writes the code

The agent's changes, scoped to the approved design.

40-impl/
◆ G3 · changes
P5
Test & review

It tests and reviews

Every acceptance criterion verified, the diff reviewed against the rubric.

50-tests.md
◆ G4 · merge — hard, always
P9
Deploy

It ships

Runs your deploy command, and closes out with the record intact.

90-deploy.md
◆ G5 · deploy
The same lifecycle ships a one-line fix or an entire product. Run it per change, per release, or point it at a greenfield build and drive the whole thing — the phases and the gates don't change, only how many times you go round.

PROJ-482 is an illustrative ticket reference. Every phase and artifact shown is exactly what Zyroflo produces.

One command. Any repo.

Drop it into the repository you already have

No packages, no network, no API keys. One command scaffolds the whole lifecycle and writes itself into the AI tool your team already uses.

install once
# scaffold the pipeline into any repo
python sdlc-init.py

# it writes a skill for whatever
# AI tool the repo already uses
✓ .sdlc/profile.yml
✓ .sdlc/policy.yml
✓ ledger check for CI
run per task
# a ticket from any tracker…
/sdlc PROJ-482

# …a plain-English requirement…
/sdlc "add SSO to the portal"

# …or an entire product build
/sdlc "build the billing service"

# resume anywhere, any tool
/sdlc resume
intakerequirements◆design◆implementation◆testreviewtriage◆releasedeploy◆verifycloseout

The 12-phase superset. The solo default lights 8; a regulated estate runs all twelve — including release, deploy and verify, which is what shipping a whole product takes. Connected to your tracker — Jira, Salesforce, StarTeam, Azure DevOps, GitHub, Linear — it pulls the item straight from there and posts the close-out back.

Enforced, not advisory

A gate you can skip is a suggestion

The gates are the whole point. AI proposes; a human disposes — and the pipeline can't route around it.

Five human gates

Scope, design, the agent's changes, the merge, and the deploy. At each one the AI stops and waits for a person to approve or reject.

The merge gate is hard, always

G4 cannot be softened in any configuration. Reject it and the pipeline loops back and tries again — it does not move until you say so.

Add a gate anywhere

Put a hard human stop after any step you like. Your organisation sets floors a project can only tighten, never loosen.

Core steps can't be deleted

Intake, implementation, review and closeout are locked. Try to drop one and the harness refuses it by name.

CI checks the ledger at merge

Continuous integration refuses a merge if a gate the run reached was never approved — or was approved over code that has since moved.

Tamper-evident by design

Every decision is a hash-chained line inside your own repository, using only the standard library — so tamper-evidence costs no dependencies.

Any model, any vendor

The pipeline is yours to shape

Which steps run, where the humans stop, and which model does which job — all in one file, or a wizard, or just in chat.

Customising the pipeline: adding a gate and removing a step SHIPS BY DEFAULT intake requirements design implement test deploy G2 G3 G4 AFTER YOUR EDITS intake requirements design implement test deploy + gate added step removed gemini-2.5 gpt-5 claude-opus-5 Same superset. Your steps, your gates, your model on each one.
.sdlc/profile.yml
# pick the model per step
models:
  requirements: openai/gpt-5
  design:       google/gemini-2.5
  review:       anthropic/claude-opus-5

# delete a step, add a gate
phases: [intake, design, …]
extra_gates: [test]
providers.toml
# providers are data, not code —
# add one by adding a table
[openai]
protocol = "openai"
key_var  = "OPENAI_API_KEY"

[anthropic]
protocol = "anthropic-messages"
key_var  = "ANTHROPIC_API_KEY"
The harness itself never calls a model. Your keys, your providers, your spend. Zyroflo governs the work — it never does the spending, and it never phones home.
Proof, not promises

Every decision leaves a receipt

Who decided, when, and why — all answerable, as the work happens, in your own repository.

.sdlc/runs/<run-id>/events.jsonl
// each finished step — one append-only, hash-chained line
{ "step": "design", "actor": "model-endpoint",
  "provider": "google", "model": "gemini-2.5",
  "tokens": {"input": 8140, "output": 1920}, "cost": 0.031,
  "duration_ms": 42180, "outcome": "ok",
  "artifacts": ["30-design.md"], "prompt_sha256": "9f2c…" }

// each gate — who, when, and how long it waited on a human
{ "gate": "G2", "decision": "approved", "approver": "a.rahman",
  "waited_ms": 5400000, "ledger_hash": "c07b…" }
See the whole estate

From one repository to all of them

Those receipts become a dashboard — and roll up across every repo you run, without the harness ever holding a connection string.

One offline file

A single dashboard.html — no CDN, no third-party JavaScript. Tabs for runs, gates, models, rework. It opens on a locked-down laptop.

Query it, or read it in Grafana

Export to SQLite and Grafana reads it directly — a stable, documented column dictionary and a ready-to-import dashboard.

Roll up across the estate

Merge many repos into one store, de-duplicated on the event hash, grouped by the owner and criticality you set at install — identities pseudonymised if your policy says so.

The destination is a directory, never a service. Zyroflo writes files to a path; your own pipeline collects them. And a number nobody could measure is never drawn as zero — it shows its reason.
Zyroflo Agents · Enterprise · private preview

Put AI agents to work inside the gates

The open-source harness governs work that your AI tools do. Zyroflo Agents brings the workforce too — specialised agents that run the lifecycle for you, treated like new joiners: scoped access, a budget, a reviewer, and a record of everything they did.

01
Analyst

Turns the request into requirements

Questions first, then options, then acceptance criteria that can each be shown true or false at the end of the run.

◆ requirements approved by a person
02
Design

Plans the change

A change set, a test plan, the decisions behind it and what else it touches. Nothing is built before a person approves it.

◆ design approved by a person
03
Developer ⇄ Review ⇄ QA

Builds, reviews and tests in a loop

A review agent and a QA agent send the work back until review is clean and every acceptance criterion passes. Still failing after three rounds, a person decides.

◆ change approved by a person · four-eyes where you need it
04
Pull request

Opened only after QA passes

The change arrives as a pull request with its reports attached. The merge stays a human decision.

Two pipelines ship built in — feature delivery and bug fix. Add your own agents and pipelines; changes to them go through a reviewed pull request.

Specialised agents, plus your own

Analyst, design, developer, code review and QA out of the box. Write a new agent as a plain markdown file; your organisation's policy always wins over a team's or a repo's.

Hard budgets and a kill switch

Every run, step and team has a spending limit that stops the work, not just warns. One command halts every agent — across the organisation, a team, or a single repository.

An audit trail you can prove

Every agent action and every approval lands in a hash-chained ledger. Verify it, export it with its chain proof, and show an auditor exactly where anything changed.

Roles, access and offboarding

Role-based access for people, teams and CI service accounts. Offboarding someone revokes their tokens and gateway keys and stops their running work in one step.

Learning a person approves

Agents learn from your corrections — but each lesson is a proposal a person approves. It runs its regression check and can always be reverted. A finding rejected in several repositories becomes one organisation-wide proposal, measured for regressions and approved by an admin in the portal.

Cost and quality, per team

Dashboards for adoption, agent quality, safety limits and executive ROI, and a monthly chargeback report so each team sees what its agents cost.

An agent for each step — yours, or a vendor's. A pipeline names the agent that runs every step, so you choose how each one behaves.
  • Define your own. An agent is a plain markdown file. Each step names its agent, and yours sit beside the built-in ones.
  • Its model and effort. Each agent picks a model tier and an effort level (low, medium or high). Your organisation maps the tiers to models.
  • Its backend. Run an agent natively, or on Claude Code or Codex.
  • A ceiling it can only narrow. Every agent has an organisation-defined type. It may use fewer tools or a smaller budget than its type, never more.
Any model provider, through one governed gateway. Every agent call goes through TokenLean, included with Enterprise — your keys, your providers, an identity on every call, and hard spend caps per team.
Enterprise's control plane and Zyroflo Agents run as one system.
  • One identity. People and agents answer to the same identity: people sign in through Zyroflo's SSO.
  • One witness. Every agent run's ledger head goes to the same outside, tamper-evident witness.
  • One console. Agent runs, spend, hard caps and the kill switch sit beside people's approvals.
  • Campaigns that start agents. A work item in a campaign can start an agent pipeline directly.
The four numbers that matter

Governance you can put on a board slide

Zyroflo measures the DORA four — lead time, deploy frequency, change failure rate, time to restore — plus the two most teams can't see at all: rework and how long work sat waiting on a human.

◆ Illustrative dashboard · sample data, not a performance claim
Lead time 6.2 days ↓ from 10.5
Change failure rate 4.1% ↓ from 11.0%
Rework per change 0.4× ↓ from 1.1×
Gate wait (human) 9.1 hrs ↓ from 31.6

Why it moves: the next phase starts the moment a gate clears — and the waiting itself is measured, so the bottleneck stops being invisible.

Why it moves: nothing merges without its gate approved over the current code. CI refuses the rest, so defects are caught at review, not in production.

Why it moves: the clarifying questions happen at requirements — before design, not after implementation, when the fix costs two orders of magnitude more.

Why it moves: machine time and human time are recorded separately, so you can finally tell a slow pipeline from a slow approver.

Read those figures honestly: they are sample data from a demonstration run, shown to illustrate what the dashboard reports. They are not an average, not a benchmark, and not a promise. Zyroflo's claim is narrower and firmer — it measures these numbers on every run, in your own repository, so you can hold us to yours.

Editions

Start free. Govern the organisation. Put agents to work.

The open-source harness is complete on its own. Enterprise is built on top of it — it imports the free engine and never forks it — and adds what an organisation needs to run AI-driven delivery at scale.

Open source

Zyroflo

MIT · v1.0 · $0
The whole lifecycle in one repository, or many. No packages to install, no network, no API keys — and nothing in it will ever move behind a paywall.
  • The full engine
  • 12 phases and 5 human gatesYours to shape; the merge gate is hard in every configuration.
  • Hash-chained approval ledger, checked by CIWith optional signed entries and a separation-of-duties policy.
  • Audit trail, metrics and dashboardsOffline HTML, SQLite and Grafana, and a roll-up across repositories.
  • Plugs into 7 AI coding toolsAny model on any step; the harness itself never calls one.
  • Yours to run
  • Community supportGitHub issues and full documentation.
View on GitHub →
Private preview · design partners

Zyroflo Enterprise

Everything in open source, for the whole organisation
Two parts under one agreement: a control plane that governs every repository, and Zyroflo Agents, the governed AI workforce. The control plane receives ids and hashes, never your code.
  • Control plane
  • Every approval tied to a real identitySSO, SCIM provisioning and roles per gate.
  • An outside witnessA tamper-evident record of every approval, outside the repository.
  • One signed org policyChecked in every repository's CI.
  • Compliance packs, scorecard and one consolePlus fleet management, tracker intake and org-wide campaigns.
  • Zyroflo Agents · new
  • Analyst → design → developer → review → QAPlus agents and pipelines of your own.
  • Hard budgets and a kill switchFrom the whole organisation down to one repository.
  • Roles, offboarding and a verifiable audit trailWith chargeback per team and human-approved learning.
  • One system with the control planeShares its identity, witness and console.
  • Model gateway
  • TokenLean includedEvery agent call through one governed gateway, on your own provider keys.
  • Partnership
  • Hands-on onboarding and a direct line to the foundersDesign partners shape the roadmap and get founding-partner terms.
Talk to us about Enterprise →
What's real today

Open source today. Enterprise with design partners.

Zyroflo is the delivery discipline behind our own work, now a product. Here is exactly where each part stands.

Resources

See it, then read the story

A short walkthrough of one ticket end to end, and the deck we take design partners through.

Enterprise · design partners

Shape Enterprise with us

The open source is yours today. We're opening Zyroflo Enterprise and Zyroflo Agents to a small first cohort of design partners ahead of general availability — so you're not just a user, you're shaping how AI-driven delivery gets governed.

◆ Design-partner cohort

Build your governance model into the product

We're keeping the first cohort deliberately small so every partner gets real attention. In exchange for working with us to make Zyroflo better, design partners get:

  • Direct influence on the roadmapYour steps, your gates, your governance model shape what we build and prioritise next.
  • Hands-on onboardingA direct line to the founders and help wiring Zyroflo into your repos and your models.
  • First accessRun it on your real work before general availability, and help set the bar.
  • Founding-partner termsWe'll recognise the partners who came in early and shaped the product with us.