BranchPoint

Architecture Diagram

Inspiration: Git for Agents

Agent Launchpad makes it easy for autonomous Agents to work on real codebases. They can create files, run commands, fix errors, and continue developing a project through natural language instructions.

While experimenting with it, we noticed a problem. Agent execution is very forward-moving.

If an Agent makes several changes and we later realise an earlier approach was better, simply restoring the old files may not be enough. The Agent could still have conversational context from everything that happened afterwards.

Trying another solution could also mean overwriting a working workspace or losing the context that led to the original implementation.

This becomes even more complicated when multiple users and Agents are working on the same project.

We started asking questions like:

What if an Agent introduces a bad change? Can we return to an earlier Agent state and continue from there?
Can we try two different solutions without them affecting each other?
Which Agent, user, and Run actually introduced a change?
How can multiple Agents safely contribute to the same codebase?
How do we prevent unsafe Agent-generated code from reaching the project's main workspace?

Traditional Git helps us version code, but autonomous Agents also have execution history, conversational context, workspace state, and provenance that affect what they do next.

This led us to build BranchPoint, a middleware layer that brings versioning, recovery, isolation, security, and governance to autonomous Agent development.

Observability tells us what an Agent did. BranchPoint lets us safely decide what happens next.

What it does

BranchPoint is a collaboration and governance middleware layer built on top of Agent Launchpad.

For individual Agents, BranchPoint provides a Git-like execution history where users can:

Create recoverable checkpoints
Restore previous workspace states
Create independent branches from older checkpoints
Merge branches to main with smart conflict resolution
Preserve Agent conversational context when branching
View live execution traces
View a live preview of the website being built, allowing users to immediately see and validate Agent-generated changes

A branch does not just copy the files. It also preserves the Agent's conversation up to that checkpoint, allowing the branched Agent to continue with the correct context.

BranchPoint also supports collaboration through parent and child Agents with isolated workspaces.

Each user can experiment within their own Agent workspace without immediately affecting the project's main codebase. When a child Agent's work is ready, it goes through security analysis and an approval process before it can be promoted into the project's canonical workspace.

Our overall workflow is:

Trace > Checkpoint > Branch > Recover > Review > Merge

How we built it

We built BranchPoint directly into Agent Launchpad rather than creating a separate application.

Our middleware observes Agent Runs, detects workspace changes, captures checkpoints, and tracks the relationships between Agents, Runs, branches, users, and workspaces.

Each checkpoint stores a recoverable workspace snapshot together with information about the Run and its observable execution events.

One of the more interesting problems was preserving Agent memory.

For example, suppose an Agent creates:

CP1 > CP2 > CP3 > CP4 > CP5

If we branch from CP2, the new Agent should remember everything that happened up to CP2, but it should know nothing about CP3, CP4, or CP5.

To achieve this, BranchPoint records the relevant point in the Codex session when a checkpoint is created. When branching, we fork the conversation from that recorded point so the new branch continues with the appropriate conversational history.

We also added project-level parent and child Agents, isolated workspaces, automated security analysis, merge approval, multi-user identity, and live trace streaming.

Challenges we ran into

One of our biggest challenges was realising that versioning an Agent is different from versioning normal source code.

Copying and restoring files is relatively straightforward. Preserving the correct Agent context is much harder.

If we restore an old workspace but the Agent remembers conversations that happened afterwards, then we have not truly returned the Agent to that earlier point.

If a branch changes a prompt in the middle of the conversation, we cannot edit that single prompt within the existing Agent context. Instead, we reconstruct a new Agent thread using the merged sequence of prompts and responses, ensuring that its context matches the merged workspace.

Workspace isolation was another challenge. Once multiple Agents and users are involved, one Agent's experimental changes should not accidentally overwrite another Agent's work.

We also had to understand the existing Agent Launchpad architecture and its Agent, Run, workspace, and Codex session lifecycle. We wanted BranchPoint to work as middleware around the existing platform instead of simply rewriting how Agent Launchpad works.

Accomplishments that we're proud of

We're especially proud that BranchPoint branching is more than just copying a folder.

A branch can restore an earlier workspace and continue with the Agent's conversational memory from that point in time.

We also managed to connect several features into a single workflow:

Tracing > Checkpoints > Branching > Recovery > Security > Approval > Merge

BranchPoint also records who performed important actions, allowing changes and decisions to be associated with individual users and Agents.

What we learned

We learned that autonomous Agent collaboration creates problems that traditional source control does not completely solve.

With Git, we mainly care about tracking code changes.

With autonomous Agents, we also need to know:

Who made the change?
Which Agent produced it?
Which Run caused it?
What context did the Agent have at that point?
What did the workspace look like before the change?
Can we safely recover from it?

We also learned that as Agents become more autonomous, isolation, traceability, security, and governance become increasingly important.

Agents should be able to experiment quickly, but developers still need control over what eventually becomes part of the main project.

What's next for BranchPoint

BranchPoint can evolve by bringing familiar Git workflows to AI-assisted development.

Future versions could support rebasing branches onto updated checkpoints, cherry-picking individual agent changes or conversations, stashing experiments, and using AI-assisted bisecting to identify when a regression was introduced.

This would make BranchPoint feel like a natural extension of Git by versioning not only code, but also the prompts, decisions, and AI-generated work behind it.

Additionally, we also plan to generalise live previews beyond websites. In the future, BranchPoint could provide interactive previews for applications and rendered previews for formatted documents, presentations, and other Agent-generated outputs.

Ultimately, our goal with BranchPoint is simple: