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.
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.
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
Turns a one-liner into a full statement of what is being asked.
Scope, data, errors, performance. Questions first, then testable acceptance criteria.
Options with trade-offs and a recommendation, against your standards.
The agent's changes, scoped to the approved design.
Every acceptance criterion verified, the diff reviewed against the rubric.
Runs your deploy command, and closes out with the record intact.
PROJ-482 is an illustrative ticket reference. Every phase and artifact shown is exactly what Zyroflo produces.
No packages, no network, no API keys. One command scaffolds the whole lifecycle and writes itself into the AI tool your team already uses.
# 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
# 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
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.
The gates are the whole point. AI proposes; a human disposes — and the pipeline can't route around it.
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.
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.
Put a hard human stop after any step you like. Your organisation sets floors a project can only tighten, never loosen.
Intake, implementation, review and closeout are locked. Try to drop one and the harness refuses it by name.
Continuous integration refuses a merge if a gate the run reached was never approved — or was approved over code that has since moved.
Every decision is a hash-chained line inside your own repository, using only the standard library — so tamper-evidence costs no dependencies.
Which steps run, where the humans stop, and which model does which job — all in one file, or a wizard, or just in chat.
# 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 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"
Who decided, when, and why — all answerable, as the work happens, in your own repository.
// 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…" }
Those receipts become a dashboard — and roll up across every repo you run, without the harness ever holding a connection string.
A single dashboard.html — no CDN, no third-party JavaScript. Tabs for runs, gates, models, rework. It opens on a locked-down laptop.
Export to SQLite and Grafana reads it directly — a stable, documented column dictionary and a ready-to-import dashboard.
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 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.
Questions first, then options, then acceptance criteria that can each be shown true or false at the end of the run.
A change set, a test plan, the decisions behind it and what else it touches. Nothing is built before a person approves it.
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.
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.
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.
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.
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.
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.
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.
Dashboards for adoption, agent quality, safety limits and executive ROI, and a monthly chargeback report so each team sees what its agents cost.
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.
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.
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.
Zyroflo is the delivery discipline behind our own work, now a product. Here is exactly where each part stands.
A short walkthrough of one ticket end to end, and the deck we take design partners through.
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.
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: