← Back to blog

Vercel just open sourced Open Agents.

It's a reference app for running background coding agents. Web UI, agent runtime, sandbox orchestration, GitHub integration. Basically the pieces you need to go from prompt to code changes without babysitting the agent on your laptop.

That matters because it shows where this is going.

The workflow is moving from:

one developer
one branch
one PR

to:

multiple agents
multiple branches
multiple PRs
all moving at once

That is powerful. It is also where the current workflow starts to crack.

Because a PR can be correct by itself and still be wrong in context.

Agent A changes a function signature.

Agent B writes tests against the old version.

Agent C updates the frontend against a stale API shape.

Every branch passes CI on its own. Every PR looks fine in isolation. Git says the merge is clean.

Then the combined system breaks.

CI answers:

"Does this branch work against main?"

It usually does not answer:

"Does this branch still work with the other open branches that are about to merge?"

That question did not matter as much when humans were opening a few PRs at a time and coordinating in Slack.

It matters a lot more when background agents are generating branches continuously.

Cross-branch verification

That is the category I care about.

Not code review.
Not linting.
Not runtime observability.

A pre-merge check that asks whether open branches are structurally compatible with each other.

Examples:

• one branch adds a required parameter while another still calls the old function
• one branch changes an API contract while another assumes the old payload
• one branch moves a GraphQL mutation while another thinks it was deleted
• two dependency or config changes are safe alone but unsafe together

None of this is exotic. These are normal engineering bugs.

The difference is concurrency.

When agents make parallel PRs easy, "safe to merge" can't only mean "this PR passed CI by itself."

It has to mean:

What I'm building

That is what Rosentic does.

Rosentic runs as a GitHub Action. One YAML file. It scans active branches against each other and surfaces compatibility conflicts before merge.

The setup is intentionally boring:

name: Rosentic Scan
on:
  pull_request:
    branches: [main]
jobs:
  rosentic:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: Rosentic/rosentic-action@v1

Open Agents is a strong reference architecture for the generation side of the loop.

I think the next layer is verification.

If background coding agents become normal, cross-branch verification should become normal too.

Per-PR CI tells you whether a branch looks safe alone.

Rosentic asks the question that matters once agents are working in parallel: