AI-driven software development
AI-driven development with a human at every gate.
AI has made the work fast. We make it governed: bounded agents run the repeatable jobs, every output lands in the record, and nothing ships without a person approving the design and reviewing the release.
Start a project- governed states per run
- 9
- human gates, every run
- 2
- of transitions in the audit log
- 100%
What governed AI development gives you
-
Speed you can audit
Agents produce research, designs, implementations and tests in minutes. The record says which agent, which inputs, which outputs.
-
People where judgement matters
Design approval and manual review are human gates on every run. Agents never move a run past them.
-
No prompt-and-pray
Agents are bounded by skill files and policy definitions you approve. They read artifacts and write artifacts, nothing else.
-
Replayable decisions
Any job can be re-run against a new model or policy and compared, because the inputs are in the record.
-
Consistent across developers
The workflow is the process. Outcomes do not depend on who picked up the ticket or which assistant they prefer.
-
Answers for compliance
Which model did what, approved by whom, with every transition logged.
When AI-driven development needs governance
These are the signs that the speed has outrun the record.
- 01
Pull requests arrive without a requirement
Code exists; the reason for it is in a chat window that has been closed.
- 02
Review cannot keep up
More output than people can read, with no structure that says what needs a human.
- 03
Every developer has a different setup
Tools, prompts and agents differ per person. Quality depends on luck.
- 04
Something shipped and nobody knows why
The decision cannot be reconstructed because nothing recorded what was known at the time.
- 05
You have been asked to audit the AI
Security, legal or a customer wants the model, the inputs and the approvals.
- 06
Vibe-coded software needs a cleanup
It works, mostly. It has no tests, no record and no gates. Bring it in as a feature request.
Do two or more of these apply? Tell us which ones and we reply with how we would run it.
How we apply AI across the lifecycle
-
Research and requirements
Agents draft research reports and PRDs from your feature request. You approve the design package.
-
Design
Data models, APIs and interfaces proposed as artifacts, reviewed at the first gate.
-
Implementation
Agent jobs on runners under release controls, with the implementation package in the record.
-
Automated QA
Test generation and execution as a job that writes a QA report before any person reviews.
-
Manual review
The second human gate, with the agent output attached and the reviewer logged.
-
Your own agents
Bring your own skill files and policies and run them on your runners.
Read more
The lifecycle, with AI where it belongs
- 01
Discovery
A week with the people who own the problem. We write the feature request as the first artifact of the run and agree what done means before anything is designed.
In the record feature_request, scope, success measures
- 02
PRD and design package
Research, requirements and design are produced inside the workflow and land in the record as artifacts you can read, comment on and reject.
In the record research_report, prd, design_package
- 03
Design approval
A human gate. The run waits until you approve the design package. Nothing is built that the record does not say is being built.
In the record design_approval transition, logged with the approver
- 04
Development
Implementation runs as jobs on runners in short cycles. You see every transition as it happens, with the implementation package growing in the record.
In the record implementation_package
- 05
Automated QA and manual review
Automated QA runs first and writes a report. Manual review is the second human gate. Failures escalate instead of slipping through.
In the record qa_report, review_report
- 06
Release and operation
A release candidate leaves the loop only after both gates pass. We deploy it, monitor it and operate it, and the next request starts the next run.
In the record release_candidate, released
Governed AI development against the alternatives
| Item | AI assistant per developer | AI agency | Sydeso |
|---|---|---|---|
| Where AI runs | Each editor | Undisclosed | Bounded jobs on runners inside the workflow |
| What is recorded | Commits | Deliverables | Every artifact, job and transition with its actor |
| Who approves | Code review, if it happens | The agency | You, at two logged gates |
| Consistency | Per person | Per project | Per template |
| Replay | No | No | Re-run recorded inputs against a new model |
| Ownership | Yours | Depends on the contract | Yours, on a public platform |
Three ways to work with us.
-
For a team that needs the application built and run
Partner engagement
We own the application end to end: discovery, PRD, design, build, QA, release and operation. You hold the approval gates.
- Priced per project, scoped at discovery
- Your gates, our runs
- We operate production after launch
-
For a team that wants to run AI-driven delivery itself
Hosted platform
Your team and your feature requests on the Sydeso platform, with managed runners, storage, backups and upgrades operated by us.
- Per workspace, monthly
- Managed runners
- Support from the people who built it
-
For a team that keeps everything on its own infrastructure
Self-hosted
Clone the repository and run the same platform on Postgres, Redis and S3-compatible storage. Free under BUSL-1.1, AGPL-3.0 from 2030.
- Free
- Your runners, your data
- Community support on GitHub
Questions
- Is the code written by AI?
- Much of it is drafted by agents and all of it is recorded as such. People approve the design, review the release and hold responsibility for both.
- Which models do you use?
- The ones the design package names. The record shows which model ran each job, so changing models later is a re-run against the same inputs.
- How do you stop agents from making things up?
- Agents are bounded by policy, read only the artifacts in the run, and write outputs that a person reviews before anything ships. Automated QA runs before manual review.
- Can our developers use this on their own work?
- Yes. The platform is hosted per workspace or self-hosted free. Your team runs feature requests through the same governed states.
- How quickly do you reply?
- By email, with how we would run the work, not a call to book a call. Send one paragraph about what should ship first and you get a written answer.
- Do we have to use the Sydeso platform?
- Every partner engagement runs on it, because the record it keeps is how we work. You can host it yourself from day one or move to self-hosting later; the platform is public under BUSL-1.1.
- What happens to the work if we stop?
- Everything is in the record as artifacts: requirements, design packages, implementation packages, QA and review reports. You keep all of it, and the platform that reads it is yours to run.
Run one feature, governed.
Give us a feature request and we run it through the workflow and send you the record.
Start a project