Manus GitHub two-way sync mirrors every change between your Manus project and a connected GitHub repo automatically — edit in either place and the other updates within seconds, unless a merge conflict, a moved file, or a broken webhook silently stops the sync.
Stuck Syncing? Get It Fixed Today
Two-way sync issues usually come down to one broken link in the chain — and it’s rarely obvious which one. We’ll audit your Manus-to-GitHub setup and get it syncing cleanly again.
How Manus GitHub Two-Way Sync Actually Works
Manus connects to a GitHub repository through a webhook and an internal file-tracking layer. When you export your Manus website to GitHub for the first time, Manus creates a snapshot of your entire project — pages, components, assets, and config files — and pushes it as an initial commit.
From that point on, two channels stay open:
- Manus → GitHub: Every save inside the Manus editor queues a commit. Manus batches small edits and pushes them on a short delay (usually a few seconds to a couple of minutes), not instantly on every keystroke.
- GitHub → Manus: When you push a commit directly to the connected branch — from your local machine, a teammate, or a CI job — GitHub’s webhook notifies Manus, which pulls the diff and re-renders the affected pages in your project.
Both directions rely on the same thing: a consistent file structure that both systems agree on. Manus maps its internal component tree to a specific folder and file layout in the repo. As long as neither side reorganizes that structure outside the expected flow, sync stays invisible and automatic.
The 3-Second Rule: What Counts as “Real-Time”
Sync isn’t instant — it’s near-real-time, and understanding the delay prevents a lot of false alarms:
- Manus batches editor changes for a few seconds before committing, so rapid consecutive edits become one commit, not ten.
- GitHub webhooks typically fire within 1–5 seconds of a push, but Manus still needs to process the payload and re-render, adding a short buffer.
- Large asset changes (new images, big component refactors) take noticeably longer than a one-line text edit.
If a change hasn’t appeared after a minute or two, that’s a signal something broke — not just normal latency.
What Breaks Manus GitHub Two-Way Sync
1. Editing the Same File in Both Places at Once
The most common failure: you edit a component in Manus while a teammate edits the same file directly in GitHub. Neither system has real-time conflict resolution the way Git merge tools do — Manus expects to be the source of truth for its own commits, so a manual GitHub edit that lands mid-sync can get silently overwritten on the next Manus push, or vice versa.
Avoid Sync Conflicts Before They Cost You Work
A clear branching and edit workflow stops overwritten changes before they happen. We set up a repo structure that keeps Manus and your dev team out of each other’s way.
2. Renaming or Moving Files Outside Manus
Manus tracks files by path. If someone renames a component file or restructures folders directly in GitHub, Manus can lose the mapping between its internal editor state and the repo. The result: the file reappears as “new” on the next sync, and the old path shows as deleted — even though nothing was actually removed from the site.
3. Force-Pushing or Rewriting History
Manus’s sync engine reads commits as they arrive, in order. A git push --force that rewrites history (squashing, rebasing, or amending already-synced commits) can desync the webhook’s expected commit chain, causing Manus to either miss changes entirely or attempt to reapply commits it already has.
4. Webhook Deauthorization or Expired Tokens
The GitHub webhook connection relies on an access token. If repo permissions change, the token is revoked, or the GitHub App loses access (common after an org ownership transfer or a permissions audit), sync stops silently — Manus won’t always throw a visible error immediately, it just stops receiving pushes.
5. Branch Protection Rules Blocking Direct Pushes
If the connected branch has protection rules requiring pull request reviews before merging, Manus’s automated commits can be blocked from landing directly. Sync appears “broken” when really it’s working exactly as configured — Manus’s commits are just queued behind a PR that needs approval.
6. Large Binary or Asset Files Exceeding Limits
GitHub caps individual file sizes, and very large uploaded assets (high-res images, video files) pushed from Manus can fail to sync if they exceed repo limits or aren’t routed through Git LFS. The page updates in Manus, but the corresponding asset never lands in GitHub.
7. Modifying Manus-Generated Config or Build Files
Manus generates certain structural or config files it relies on to map the repo back to your project. Manually editing these files in GitHub — even small formatting changes — can break Manus’s ability to parse the repo state on the next pull, since it’s expecting a specific machine-generated format.
Get Your Manus Site Back in Sync
Whether it’s a broken webhook, a conflicting edit, or a config file issue, we diagnose the exact break point and get both sides talking again — without losing your work.
How to Diagnose a Broken Sync
- Check the last successful commit timestamp in both Manus and GitHub — a big gap points to when sync stopped.
- Look for pending pull requests on the connected branch if branch protection is enabled.
- Re-authenticate the GitHub connection in Manus’s project settings if the token may have expired.
- Compare file paths, not just content, between the two systems — a silent rename is one of the hardest breaks to spot.
- Avoid manual force-pushes to the synced branch unless you’re prepared to manually reconcile Manus afterward.
Best Practices to Keep Sync Reliable
Treat the connected GitHub branch as Manus’s territory. If your team needs to make direct code changes, work in a separate branch and merge deliberately, rather than committing straight to the branch Manus watches. Keep large assets out of the repo where possible, and avoid manually touching Manus-generated config files. This same discipline matters whether you’re troubleshooting sync or working through why a Manus site isn’t showing up on a custom domain — most Manus issues trace back to something changed outside Manus’s expected flow.
If you’re setting up DNS alongside your GitHub sync, it’s worth knowing the difference between A records and CNAME records for Manus, since domain misconfigurations are a separate — but equally common — source of “why isn’t my site updating” confusion.
Conclusion
Manus GitHub two-way sync works reliably as long as both sides respect the same file structure and edit rhythm — but force-pushes, manual renames, expired tokens, and branch protection rules are the most common ways to break it. Diagnosing a broken Manus GitHub two-way sync almost always comes down to finding which side changed something the other side wasn’t expecting.
Not Sure Where Your Sync Broke?
Let us take a look. We’ll pinpoint the exact issue — conflict, config, or connection — and get your Manus and GitHub repo back in sync.
FAQ
Does Manus sync every single edit to GitHub instantly?
No. Manus batches editor changes for a short delay (typically a few seconds to a couple of minutes) before committing, so rapid edits become fewer, larger commits rather than one commit per keystroke.
Can I edit my Manus site’s code directly in GitHub?
Yes, but direct GitHub edits can conflict with Manus’s own commits if made to the same file around the same time. It’s safer to make direct code changes in a separate branch and merge deliberately.
Why did my Manus site stop syncing with no error message?
The most common silent cause is an expired or revoked GitHub access token, often after a permissions change or org ownership transfer. Re-authenticating the connection in Manus’s project settings usually resolves it.
Will force-pushing to my GitHub repo break Manus sync?
It can. Force-pushes that rewrite commit history can desync the webhook’s expected commit chain, causing Manus to miss changes or attempt to reapply commits it already has.
Why do large images or videos I add in Manus not show up in GitHub?
GitHub has file size limits, and large binary assets can fail to sync if they exceed those limits or aren’t routed through Git LFS. The change appears in Manus but never lands in the repo.