Open source Self-hosted · Apache 2.0

A software team made of AI agents, and you approve every step.

Write what you want built. A Product Owner turns it into a backlog, an Architect into a plan, specialists build it phase by phase, QA writes the tests and DevOps opens the pull request. Nothing moves past a gate until a person says yes.

Download & run View source
terminal
$ docker run -d --name slipwright -p 8500:8500 \
    -v slipwright-state:/data -v slipwright-work:/work \
    ghcr.io/ksksertac/slipwright:latest
amd64 & arm64 No separate database or queue Your keys, your repository
The Slipwright project pipeline: three developments waiting for approval and a finished one opened to its request, plan and four stages
Why Slipwright

Built the other way round

Most coding agents are one model in a loop, and you find out what it did when it is finished. Slipwright keeps a person at the wheel from request to pull request.

A team, not a chatbot

Each role is its own agent with its own model, instructions and permissions. A deterministic state machine calls one role at a time, and every answer is a typed schema.

You stay in charge

Backlog, architecture, screens, test cases, tests and deployment each stop at a gate. Edit what was proposed, approve it, or send it back with a reason.

Nothing is lost

Every step is written to the database before the next one runs. Stop the server mid-development and start it again: running work carries on, waiting work keeps waiting.

Your keys, your repository

It runs on your own model keys, pushes to your own GitHub or Bitbucket, and mirrors the backlog into your own Jira.

How a development flows

From a sentence to a pull request

Every stage stops at a gate you control. The agents never talk to each other; the engine hands work from one role to the next.

  1. Your request

    Describe what you want in plain words: in the pipeline, from the CLI or from Telegram.

  2. Product Owner writes the backlog You approve

    Epics, stories and tasks, written after reading the request and the repository. Rename, add or remove anything before approving.

  3. Architect plans the phases You approve

    The stack, the build/test/run commands, the decisions and one phase per task. Reorder phases, change domains, files or commands.

  4. Specialists build, one phase at a time

    Backend, web and mobile developers do the work, with the Designer's screens ready before any UI phase. After every phase the build gate runs your build_cmd and test_cmd; a red build goes back to the same specialist (up to three times), and QA reviews the diff against your standards.

  5. QA proposes cases, then writes the tests Two gates

    Approve the test cases, then the unit and end-to-end tests written against exactly those cases. Or go on without tests.

  6. DevOps deploys and opens the PR You approve

    Deployment files, the pushed branch and a pull request described from the plan, test cases and history. CI is watched; red CI goes back to the developer who wrote the code.

  7. Merge

    The pull request link is on the development and in the activity feed. Review it like any other PR.

The team

An agent for every role

Each agent has its own provider, model, thinking depth, standards and permissions, enforced by the engine, not by the prompt.

Planning

Product Owner

Reads the request and the repository, writes epics, stories and tasks.

read_filesjira
Planning

Architect

Chooses the stack, the build/test/run commands, the decisions and one phase per task.

read_filesrun_commandsjira
Design

Designer

Draws the screens the web and mobile specialists will build, behind a gate of its own.

read_fileswrite_files
Building

Backend · Web · Mobile

Implement one phase each, in the phase's own domain, behind the build gate.

write_filesrun_commands
Testing

QA

Proposes test cases, then writes unit and end-to-end tests for the approved ones, and reviews every diff against your standards.

write_filesrun_commands
Delivery

DevOps

Proposes the deployment, writes it, pushes the branch and opens the pull request.

networkgit_push
Oversight

Supervisor

Reads every gate and recommends approve or reject, with confidence, risk and reasons.

read_files
Human

You & your team

Put a colleague on an agent: they approve and edit only at that agent's gates, and are mailed when work arrives.

approveeditreject
Tour

See it in action

Gates you can edit, a pipeline for every development and a dashboard of what waits for you.

Gates you can edit, not just approve

Each gate offers Save, Approve and Reject with a reason, and the reason goes back to the agent as feedback.

  • Supervisor advice on every gate, with confidence and risk.
  • Go on without tests when a change isn't worth testing.
  • Go on without deployment and still get the pull request.
The test cases gate: the supervisor recommends approve at 0.86 confidence, with QA's proposed cases open for editing
Under the hood

Serious about getting it right

A supervisor at every gate

Per project, choose how much the supervisor does. When a build fails, it also decides whether the same specialist fixes it, whether to re-plan, or whether to ask a person.

Manual
You decide every gateNo recommendations, no automation.
Assisted
Recommendation on each gateWith its confidence, its risk and its reasons. The default.
Auto
Confident, low-risk approvals made for youRejections are never automatic, and any automatic approval can be undone.
Supervisor recommendation on a gate with confidence and risk

Built behind a build gate, reviewed against your standards

After every phase, the project's own build and test commands run. Every green phase is committed on the development's branch. Then QA reviews the diff against your standards: Markdown pages per domain, indexed for keyword and optional embedding search.

  • Review mode: off, advisory or blocking.
  • Standards edited in the app, for all projects or per project; linted, reindexed and committed.
  • Only the relevant sections go into each agent's prompt.
phase 3 · build gate
# the project's own commands, after every phase
$ uv run pytest -q
........................  24 passed in 3.1s
$ npm run build
✓ built in 2.4s
# green → committed on sw/notes-search
# QA review against standards/backend.md
review: advisory · 0 blocking findings

Any model, per agent

Pin each agent to its own provider and model. Change the model in the profile and that role runs on it. No code change, no restart.

Anthropic Claude OpenAI GPT Google Gemini DeepSeek Alibaba Qwen Z.ai GLM MiniMax ChatGPT via Codex
profile.json · roles
"architect": { "model": "claude-opus-5",
               "thinking_depth": "high" },
"qa":        { "model": "claude-sonnet-5",
               "thinking_depth": "medium" },
"devops":    { "model": "claude-haiku-4-5",
               "thinking_depth": "low",
               "permissions": ["git_push", …] }

GitHub & Bitbucket

Clone a private repository or use a local checkout. A finished development pushes its branch and opens a pull request; red CI goes back to the developer.

Jira, optionally

The approved backlog becomes epics, stories and sub-tasks. PR links and failures are commented, as a bot account you choose.

In your language

The interface is in English and Turkish. Agents write in the project's language; everything is shown in yours through a cached translation bridge.

Costs & budgets

Per-project budgets on tokens, wall-clock time and model calls stop a runaway development with a readable reason.

CLI & API

Start, approve, reject and message developments from the command line. A JSON API at /docs and server-sent events for every change.

Encrypted credentials

Model keys and tokens are stored encrypted. State and work live in separate volumes, so a checkout can never reach the key.

Local or hosted, one codebase

LocalHosted
Who writes the build commandsyoustrangers
DatabaseSQLite filePostgreSQL
Commands runon the machinein a throwaway container
Model keysthe installation'seach account's own
Quotasoffon
Get started

Download and run in a minute

One image holds everything: the API, the web UI, git, gh, Python and Node. There is no separate database or queue to run.

published image · nothing to clone or build
docker run -d --name slipwright -p 8500:8500 \
    -v slipwright-state:/data -v slipwright-work:/work \
    ghcr.io/ksksertac/slipwright:latest
# first login (becomes admin)
docker exec -it slipwright slipwright user add ada

Open http://localhost:8500. Keep /data and /work as two separate volumes: /data holds the key that decrypts every stored credential.

  1. Settings → ModelsPaste a key for at least one provider and click Test connection.
  2. Settings → SourcesAdd a GitHub or Bitbucket token to clone, push and open pull requests.
  3. Projects → New projectPick a repository; Slipwright reads it and proposes a brief.
  4. New developmentDescribe what you want, then answer the gates as they arrive.

ghcr.io/ksksertac/slipwright

Every push to main publishes :latest for amd64 and arm64; a v1.2.3 tag publishes :1.2.3 as well.

Open the package
Open source

Built in the open. Come build it with us.

Slipwright is fully open source under the Apache 2.0 license. Read every line, run it anywhere, fork it, and help shape where it goes next.

Contributions are welcome

Bug reports, fixes, new model providers, translations, documentation and ideas all help. Every contribution goes through a pull request on GitHub.

  • Found a bug or have an idea? Open an issue and describe it.
  • Want to write code? Fork the repository, make your change on a branch and open a pull request.
  • New to the codebase? CLAUDE.md is the orientation: the layout, the rules that are easy to break and the mistakes already made.
  • Like the project? A star on GitHub helps others find it.
Contribute on GitHub Open an issue
contributing · github.com/ksksertac/slipwright
# fork on GitHub, then
git clone https://github.com/<you>/slipwright.git
cd slipwright && git checkout -b my-change
uv sync
# the whole suite, lint and types
uv run pytest
uv run ruff check . && uv run mypy
cd web && npm install && npm run lint && npm run build
# push and open a pull request
git push origin my-change
FAQ

Questions, answered

Is Slipwright free?

Yes. Slipwright is open source under the Apache 2.0 license. You pay only for the model API calls your agents make, with your own keys.

How do I install Slipwright?

Run the published Docker image with the command above, create the first login with docker exec -it slipwright slipwright user add <name>, and open http://localhost:8500. A “Getting set up” card on the dashboard walks you through the rest.

Which AI models does it support?

Anthropic Claude, OpenAI GPT, Google Gemini, DeepSeek, Alibaba Qwen, Z.ai GLM and MiniMax work out of the box, and each agent can be pinned to its own provider and model. On a self-run install, agents can also use a ChatGPT subscription through OpenAI's Codex CLI.

Does my code leave my machine?

Slipwright runs on your machine or server. Code is sent only to the model providers you configure, and pushed only to your own GitHub or Bitbucket repository.

Can I try it without API keys?

Yes. Set SLIPWRIGHT_PROVIDER=scripted to run the whole pipeline on canned model replies. A new account also starts with Example: a Notes app, a finished development to read before you run one of your own.

What happens if the server stops mid-development?

Nothing is lost. Every step is written to the database before the next one runs, so running work carries on and work waiting for you keeps waiting.

Is it open source? Can I contribute?

Yes. The full source is on GitHub under the Apache 2.0 license. Open an issue for bugs and ideas, or fork the repository and send a pull request.

Can I run it for a team or as a hosted service?

Yes. Switch to PostgreSQL, run every command in a throwaway container with SLIPWRIGHT_RUNNER=docker, and turn on sign-up, per-account keys and quotas. None of it is on by default, so a local install stays a single command.

Put a team to work. Keep the final say.

Self-hosted, open source and running on your own keys. One command to start.

Get the Docker image Star on GitHub