Every AI coding product has to answer the same question: what happens to the code after the agent writes it? Some tools apply changes directly to your working copy. Some trap the work inside their own proprietary workspace. Veflow's answer is deliberately boring: every change becomes a real branch and a real pull request in your GitHub repo, gated by your actual CI — and every merge goes through GitHub's front door.
The mechanics
When an agent picks up a task, it works on its own branch — never on main. When the run finishes, the agent commits what it built and opens a real PR against your repository. Not a simulated diff inside our UI; a PR your team could review in GitHub right now, with Veflow nowhere in the loop.
This happens even when a run doesn't finish cleanly. If the agent hits a wall or stops to ask you something, whatever it built so far is still committed and still inspectable. Partial work isn't trapped in a chat transcript — it's on a branch.
The run ends as a pull request, whether or not the run was perfect.
Upstream of the PR, the agent isn't pattern-matching in a vacuum. It works in an isolated environment with your actual repository checked out, and its shell is real — it can run your commands, and everything it runs is visible as tool calls in the task thread. You watch the work happen at the level of commands and diffs, not a summary of them.
Review without leaving the task
The diff renders inside the task itself, next to the conversation that produced it. You read what was asked, you read what the agent did, you read the code — one screen, no tab archaeology. Each task also gets a live preview URL, so "does it actually run?" is a click, not a checkout.
When you're satisfied, the merge happens from the task too. Pick your method — merge commit, squash, or rebase — and Veflow performs a real GitHub merge through the API.
Branch protection and CI apply to every agent PR
That "real GitHub merge" is one fact that carries all the guarantees:
- Branch protection applies. If main requires status checks, the merge doesn't happen until they're green. If it requires reviews, it waits for reviews.
- Your CI is the gate. Whatever runs on your PRs — lint, type checks, tests, builds — runs on agent PRs identically, because to GitHub they are PRs, same as any human's.
- Conflicts surface, not vanish. If the branch can't merge cleanly, GitHub refuses and Veflow shows you why. Nothing force-lands.
We didn't reimplement your quality bar inside Veflow, and that's deliberate: a reimplementation would drift from the real one, and "passes Veflow's checks" would slowly stop meaning "passes yours." The only gate that can't drift from your CI is your CI.
The diff, the inline comments, and the review — without leaving the task.
Why AI agent pull requests need a harder gate, not a softer one
With human authors, skipping PR ceremony is sometimes a defensible trade. With agent authors, the PR is load-bearing in a way it never was before:
- The diff is the contract. The agent can narrate whatever it likes in chat; the PR is what's actually true.
- Nothing lands silently. There is no code path from agent to main that doesn't go through a merge you triggered — that's not a slogan, it's the architecture.
- The record outlives us. Merged PRs live in your GitHub history forever. If Veflow vanished tomorrow, every change an agent ever shipped would still be there, attributed and diffable.
One honest limit: the review conversation — inline comments, change requests — still lives on GitHub, where your team already has it. Veflow gives you the diff, the preview, and the merge button; it doesn't reinvent GitHub's review threads.
The most important property of this design is what it doesn't ask of you. Adopting Veflow doesn't mean re-deriving your quality strategy around a new tool's opinions. Your branch protection, your required checks, your review culture — all of it keeps working, unmodified, because agent code arrives through the exact door human code always has. Agents raise the volume of code dramatically; that's precisely the wrong moment to lower the bar it has to clear. So we didn't touch the bar — we just made sure everything an agent ships has to walk through it.