Syrus is the open-source, self-hosted automation harness for turning issues, chats, and video walkthroughs into tracked pull requests. Developers keep the repo, credentials, checks, transcripts, review policy, and merge queue in their own infrastructure, while product and project owners get the visibility they need without turning AI work into a black box.
Bis dat qui cito dat. “He gives twice who gives quickly.” — Publilius Syrus
Product demo
The launch walkthrough centers on the video-to-Job flow, then follows that work through tracked execution, review queues, and cost visibility.
How your team works with Syrus
Every goal turns into tracked epics and tickets, so you always see what's in progress, what's in review, and what shipped — and someone on your team signs off before anything merges, per the review policy you set.
Describe the outcome in a Syrus chat — a feature, a refactor, a whole initiative. Syrus reads your repositories and drafts the plan. Nothing becomes work until you confirm it.
Big goals become epics: dependency-ordered stacks of scoped tickets — “Jobs”, in Syrus — that your team can accept, edit, or reject before any code is written.
A developer releases the plan for execution — or triggers Syrus directly with a label on a GitHub issue, right where your code already lives.
Clones, branches, and implements in an isolated workspace — many changes in flight at once, even on the same files — then opens a pull request with the diff and a step-by-step test plan. The full transcript stays on the job record.
Your own checks — tests, lint, typecheck — grade every change, and a red result sends the agent back before the PR even opens. Syrus answers review comments; your developer brings the judgment machines can't.
Human approval gates the merge — self-review, two-person, or a designated final say: your policy. Once approved, Syrus lands it for you — rebased, re-checked on the exact branch, merged in dependency order. Branch protection, never bypassed.
Why Syrus
More output, real guardrails, and full visibility into what's being built — so you can move faster without gambling on quality.
Run many changes on one codebase at once — even changes that touch the same files. Every job works in its own isolated workspace, in-flight branches are rebased against each other automatically, and ordered work ships as stacked pull requests that land in sequence.
Your own checks — tests, lint, typecheck — grade every change, and a red result sends the agent back to fix it before a PR ever opens. Then human approval gates the merge, per the review policy you set. AI's velocity never turns into hallucinated logic slipping into production.
After sign-off, the landing queue takes over: rebase, re-run your checks on the exact branch about to merge, then merge in dependency order. Epics land as one green unit or not at all — no half-merged features on your main branch.
Goals become tracked epics and tickets, and every attempt keeps its full transcript, diff, and review — an append-only record of who asked for what and exactly what the agent did. Operational dashboards track queues, workers, and host pressure, while repository throughput metrics show PR creation, output, landing, and review flow without hiding sparse samples.
Every run records what it spent. A spending dashboard breaks AI cost down by epic, person, and repository — so you know what each feature actually cost to build, not just that it shipped.
Self-hosted on your infrastructure, and your code goes only to the plugin-backed model provider you choose, on your own credentials. Syrus only ever calls out: no inbound webhooks, no public endpoint to expose. Your issues, reviews, and merges stay in GitHub.
Six ways in, one execution model
A ticket, a review comment, a failing check, a scheduled chore — each becomes, or updates, the same tracked job, with every attempt on one timeline. Nothing happens off the books.
A labeled issue becomes a tracked job, a branch, and a pull request.
Your review comment triggers a follow-up commit on the same branch; teammates' comments queue for one-click apply.
A failing check kicks off a bounded, automatic repair attempt.
Record your screen with narration from chat. Syrus extracts issues, desired behavior, and screenshots before the agent proposes the work.
A confirmed chat proposal or a direct prompt from your team, no ticket needed — chores, experiments, urgent work.
Cron or one-shot runs for dependency chores, docs sweeps, hygiene.
An unmergeable branch gets a deterministic rebase — the agent steps in only if judgment is needed.
Download the desktop app — it sets up a complete local Syrus (Docker included) or connects to your team's instance. If you want help mapping Syrus onto your repos, checks, and review policy, send a note and we'll walk through it with you.
The product video above shows the core loop first: walkthrough to Job, implementation, review, and tracked cost.