Build in the dark.

Sadr is a dark factory for software. It works through every repo you own with the lights off, keeping each one current, secure and up to your standards, and builds the features waiting in your issues. Cygnus Strategy runs on it.

Sadr (SAD-er) is the star at the heart of Cygnus, the swan. Calm on the surface, paddling hard underneath.

Run your own How it works

In the dark

  • certifi 2026.10.18 → 2026.10.19 distrusted root removed
  • uv exclude-newer = "7 days" supply chain hardened
  • pillow 12.3.0 → 13.0.0 25 advisories fixed
  • actions/checkout → 3d3c42e pinned to v7.0.1
  • fastapi 0.148.0 → 0.143.2 inside the cooldown, stepped back
  • follow-redirects 1.16.0 → 1.16.1 leak on redirect fixed
  • npm min-release-age=7 supply chain hardened
  • setup-uv version 0.13.1 installer pinned
  • AGENTS.md: test command written down for next time
  • semgrep untriaged 3 → 0 fixed in the PR

From idea to production

Say the feature. Wake up to it shipped.

You have an idea, so you tell Claude. Claude files it as an enhancement issue. That night, Sadr builds it, alongside keeping everything else current. It merges through your checks, your CI deploys it, and you never sat through a build session.

  1. 2:14 pm · you

    You tell Claude the idea

    “Open an enhancement issue:
let people export reports
as CSV.”

  2. 2:15 pm · Claude

    It’s filed as an issue

    #142 Export reports as CSV
enhancement

  3. 3:00 am · Sadr

    The nightly run builds it

    sadr: #142 Export reports as CSV
sadr: dependencies and CI

  4. 3:52 am · GitHub

    It merges through your checks

    all checks passed
auto-merged into main

  5. 3:58 am · your CI

    And it’s in production

    deploy: production
succeeded

All it takes is two sentences in your AGENTS.md ("Build enhancement issues." and "Auto-merge everything.") and a pipeline that deploys on merge. Times are an example.

A dark factory

The lights stay off. The work still gets done.

A dark factory runs with nobody on the floor. People decide what gets made and to what standard, then check what comes out. For software, that means agents doing the work across every repo, from keeping it current and secure to building the features people asked for, while you spend your attention on review.

Cygnus Strategy builds its software this way, with Sadr. It’s open source, so you can run your own.

  1. You set the standard

    In plain sentences, in each repo’s AGENTS.md and your organization’s defaults.

  2. It runs in the dark

    On the schedule you choose, one agent per repo, with nobody watching.

  3. The work arrives for review

    Upgrades, fixes and features, with every change, every hold and anything that needs a person written down.

  4. You review, or it merges

    You merge it, or let it merge itself through your required checks.

Design principles

How we think a dark factory should work.

These are the rules we hold Sadr to. Each one is a decision about who does what, and where the truth lives.

Lights out
It runs unattended, on your schedule. People decide the standard and review the output, and nothing in between waits on them.
Stateless
The factory remembers nothing. What it knows lives in your repos and on GitHub, where you can read and change it.
Language over configuration
Your standards and settings are sentences in AGENTS.md. Any agent, and any person, can read them.
The pull request is the interface
Every change arrives the way code review already works, with the reasons written down.
Fix it, don’t file it
A real problem gets fixed in the pull request. It doesn’t become an issue for later.
Secure by default
Supply-chain defenses are on from the first run, and the factory meets them itself.
People decide what ships
Nothing reaches your default branch unless you merge it or told it to.

What it does

Everything a careful engineer would do, in every repo, every run.

  • Keeps dependencies current

    Majors included, with the code changes each one needs.

  • Upgrades runtimes and toolchains

    Languages, base images and CI versions, kept in agreement.

  • Hardens the supply chain

    Releases wait a week before they’re used, and actions and images are pinned to exact versions.

  • Fixes what scanners find

    Security findings are fixed in the PR, or explained when they aren’t real.

  • Keeps it green

    Your build and tests pass after every change. Anything that can’t move is held, with the reason.

  • Builds your features

    Enhancement issues a maintainer has accepted get built, tested and sent for review.

  • Writes down what it learns

    Build steps, quirks and constraints go into AGENTS.md for the next run.

  • Shows you first, if you ask

    A preview runs everything except pushing.

  • Stays within limits

    Time and spend caps per repo, set high by default.

  • Merges when you let it

    Off, minor changes only, or everything, per organization and per repo.

It works in whatever a repo uses: npm, uv, Go, Swift, Cargo, Gradle, Maven, Composer, .NET, Terraform, Helm, Nix, Docker, and the rest.

Review

Its work lands where you already review code.

Upkeep arrives as one pull request per repo, and each feature as its own, with what changed, what it fixed, what it held back and why, and anything that needs you. The pull request is the record; the factory keeps nothing of its own.

It merges only where you turn auto-merge on, and only through your required checks.

OPEN

sadr: run of 2026-10-26

Dependencies
fastapi 0.143 → 0.148
pydantic 2.13 → 2.14
CI
actions/checkout v6 → v7.0.1, SHA-pinned
Supply chain
turned on uv’s release cooldown
Semgrep
untriaged: 3 → 0
fixed: 3
Merging
auto-merge: minor (AGENTS.md)
Verification
uv run pytest: 142 passed

Your standards, in plain language

Tell the factory how your repo works.

Sadr reads the ## Sadr section of your AGENTS.md: how to build and test, what not to touch, what’s held back, and how it should behave. When it has to work something out, it writes it down there in its PR, so the next run, and every other agent, already knows.

An organization writes its defaults the same way, in its .github repo. A repo’s own settings win. There are no config files.

AGENTS.md

## Sadr

### Build and test
- uv sync --locked && uv run pytest

### Don’t touch
- migrations/ is generated.

### Holds
- Python held at 3.14 until the
  worker runtime supports 3.15.

### Settings
- Build enhancement issues.
- Auto-merge minor updates.
- Request review from CODEOWNERS.

Run your own

From Claude Code, or on any schedule in GitHub Actions.

Claude Code

Install the plugin and ask it to run on an org, a list of repos, or one repo. Ask for a preview to see the PRs it would open, without touching anything.

/plugin marketplace add Cygnus-Strategy/sadr
/plugin install sadr@sadr

GitHub Actions

Add one workflow and set the schedule: nightly, weekly, or on demand. Pay with a Claude subscription token or an API key.

on:
  schedule: [{cron: "0 3 * * *"}]  # nightly
jobs:
  sadr:
    uses: Cygnus-Strategy/sadr/.github/
      workflows/run.yml@<sha> # v1.0.0
    secrets:
      claude_code_oauth_token:
        ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}

Under the hood

The details, for the people who check.

The factory holds itself to the standard it enforces.

  • A 7-day release cooldown

    Nothing is installed or pinned until it has been public for a week, using each package manager’s own setting where it has one.

  • SHA pins, checked against tags

    Every action sits on the full commit SHA of a week-old release, verified against its version tag.

  • Exceptions only for real fixes

    A newer release goes in only to fix a published vulnerability, capped at that release and removed on the next run.

  • Only the secrets it needs

    One Claude credential and GitHub’s token. A secrets scan runs before every push.

  • Pinned and signed

    You call Sadr by commit SHA. Releases are signed and carry GitHub artifact attestations.

  • Sadr runs on Sadr

    The repo meets its own standard, with an OpenSSF Scorecard you can check.

  • Tested against fixture repos

    Every release runs end to end on sample repos across ecosystems before it ships.

Turn the lights off.

Sadr is free and open source under the BSD 3-Clause license.

Run your own Read the source