One shared main, no branches to review.
Push a feature. An agent integrates it into the newest main. When it hits a decision only you can make, not a merge conflict but a product one, it asks. Right in your notch.
Describe what you meant to do. The agent folds it into the newest main and syncs your checkout back.
$ synqit push "add avatars"→ integrated onto main a91f3c2
Conflict in login()
0:59 left+2 moreYour change to login()’s return type collides with Ana’s guard clause, merged 18s ago, which calls it and expects the old shape.
the actual escalation from Synqit’s end-to-end test run
From push to shared main.
Push your feature
Describe the change in plain English: synqit push "add avatars"
An agent integrates it
It reads the newest main and resolves anything it can safely decide on its own.
You decide, only when it matters
A genuine product conflict becomes three choices, right in your notch.
See your workspace, not your diff.
Built for one shared main.
Everything shared source control needs to not be Git plus a chatbot.
No branches
One shared main. Nothing to fork, nothing to open a pull request against.
Human escalation
A genuine product decision stops the agent and asks — instead of guessing and shipping the wrong call.
Native notch
A real macOS menu-bar app. Always there, out of the way until it isn't.
Precedent memory
Once you've decided a concept, the same question isn't asked twice — even from a different file.
GitHub-backed
Real commits, on your real main. doctor verifies the token can actually write before you ever push.
Open source
MIT licensed, self-hosted. Fork it, read every line that runs your pushes.
Any GitHub repo, one fine-grained token.
Point Synqit at a repo with Contents: read and write. doctor --verify exercises the permission for real, against a real ref — not an identity check that passes for any token and then fails on your first push.
Ask once. Never ask again.
A decision isn’t just logged — it’s written back into the graph as precedent for every concept the conflict touched. The next collision on the same idea, even in a different file, resolves on its own.
Escalations that don't hang your team.
- — A question waits five minutes, not forever.
- — No answer? The push ends in needs_human — your local work untouched.
- — Every fallback is today’s behavior: no notch, a timeout, too many rounds.
- — One slow decision never wedges the rest of the queue.
Every push explains itself.
Which decision was made, and why, is part of the published commit message — not a side channel that drifts from what actually shipped.
| Commit | Decision | Dev |
|---|---|---|
| a91f3c2 | kept theirs | dev_ana |
| 7c2e0d1 | mechanical | — |
| e58b420 | instructed | dev_ben |
One shared queue, however many repos.
One person runs one server. Every project your team connects shares the same notch, the same identity, the same escalation surface.
pricing-service
active
marketing-site
active
mobile-app
active
Extensible, adaptable, open source.
Read every line that runs your pushes, then change the ones you don't like.
Self-hosted
Runs on your machine or your infrastructure. No Synqit account, ever.
MIT licensed
Fork it, read it, ship your own escalation surface on top of it.
Extensible
The EscalationSurface seam means Slack, Linear, or your own UI can plug in exactly where the notch does.
Where a surface could plug in next.
Questions, answered.
How is this different from reviewing pull requests?+
There's nothing to review. One shared main — the agent integrates continuously, and only stops you for a real product call, not a stylistic one.
Does this replace Git?+
No. It replaces branches, pull requests, and merges on top of Git. GitHub stays the source of truth for every commit.
What happens if I don't answer in time?+
The push ends in needs_human after five minutes. Your local work is never touched — you can answer later and push again.
Is my code sent to a third party?+
The integration agent calls an LLM (OpenRouter by default, or your own pinned model) to reason about conflicts. Only the changed files and their intent are sent — see the docs for exactly what leaves the server.
Can multiple people push at once?+
Pushes are serialized per project — one queue, one integration at a time. No simultaneous integration race to corrupt main.
What if I haven't installed the notch?+
A conflicting push returns needs_human immediately instead of hanging. Your work stays local and unchanged until you attach a notch.
What LLM does the integration agent use?+
Configurable at synqit configure — OpenRouter by default. Pin any tool-capable model; a free router can pick a different backing model per call, so pin one before relying on stable behavior.
Is Synqit open source?+
Yes — MIT licensed. Fork it, self-host it, or swap the escalation surface for your own.
From clone to shared main in one command.
Open source. Self-hosted. First run walks you through setup — no Synqit account required.