Webinar: Git For Data- How Agents Write to Production Without Breaking It | July 14th | 9am PT

Run AI on your production data, safely.

Git for data: branch, validate, merge. The way your agents already work with code.

12 days
RealPage from zero to a lakehouse live in production
270×
Trust & Will query growth, ~75% of Snowflake compute migrated
40M+
Mediaset jobs run with zero production incidents
mediaset logoscops.ai logomoffin logotrust&will logointella logoLogo realpage
mediaset logoscops.ai logomoffin logotrust&will logointella logoLogo realpage

AI agents can iterate on code, but not on your data

Agents generate data changes at machine speed.

Production was protected by process, not by the execution model, so agents got stuck drafting code while humans did the DataOps.

Git for data moves protection into the execution layer.

Agents branch, run, and validate freely, and the merge to main becomes the human review boundary. High-iteration agent work becomes safe on real data, without turning production into an experiment.

Git-style safety for AI agents on production data.

Agents write the code, run compute against your data branches, validate results, and submit PRs for merge.

Bauplan infographic explaining the git-for-data concept

Git-like workflow for your Production Data

Branch, write, validate, merge. Like software.

A handful of predictable primitives. Every workflow, human or agent, follows the same loop, so what an engineer reviews is exactly what an agent ran. Agents work directly on production data without risk.

arrow right
01

branch

Open a zero-copy branch off main. Creating one is a metadata no-op, even at scale.

arrow right
02

run

Execute pure Python and SQL pipelines in isolation against real production data.

arrow right
03

inspect

Query any branch, diff outputs, and gate on data quality expectations before anything ships.

arrow right
04

merge

Publish to main with one atomic merge. This is the human review boundary for agent changes.

05

revert

Undo bad publishes instantaneously. Main rolls back to the last good commit, no rebuild required.

revert sends you back → start again from a clean branch

↺ revert sends you back to step 01: branch

Revert sends you back - start again from a clean branch

Work with data the same way you work with code

Everything in Bauplan is code, versioned in your repository and executed from your IDE. AI-generated changes run exactly as written, with no hidden state or manual steps.

Bring your AI coding assistant: we provide the safe execution layer.

copilot logowindsurf logogemini code assistantOpen ai codexcursor logo

Automate your Data Lifecycle

Automate data engineering workflows with simple agent skills,
from assessing the feasibility of a request to building and maintaining production pipelines at scale.

Building data pipelines

Agents and engineers build data pipelines like software: write transformations in code, run them in isolation against real data, and publish only validated results.

Safe table ingestion

AI agents diagnose pipeline failures, replay runs against the exact state that produced them, and propose fixes in isolated branches you merge when ready.

Debug & fix pipelines

Ingest new data into an isolated branch, validate it with quality checks, and publish atomically only when it passes.

Data exploration and discovery

Let agents run hundreds of profiling queries, inspect schemas, and sample rows across isolated branches to build a complete picture of your data.

95%

of the RealPage POC code written by Claude Code, live in 12 days

The merge is where I review what the agent did. I get the speed of autonomous iteration with a clean boundary before anything reaches production.

Jensen Carlsen, RealPage

Integrations

Integrate with your storage, warehouses, and developer workflow.
Read more about Bauplan integrations in our docs.

A whole data platform in your repo

Branch, inspect and merge data like code

Bauplan models the state of your data as branches and commits. Create branches, run changes, inspect history, and merge only when tests are passed.

import bauplan

client = bauplan.Client()

dev_branch = client.create_branch(
    branch="fritz.dev",
    from_ref="main",
)

tables = client.get_tables(ref=dev_branch)
print(tables)

preview = client.query("SELECT * FROM my_table LIMIT 5", ref=dev_branch)
print(preview)

assert client.merge_branch(
    source_ref=dev_branch, 
    into_branch="main"
)
import bauplan
from bauplan.standard_expectations import expect_column_no_nulls

@bauplan.model()
@bauplan.python("3.11", pip={"pandas": "2.2.0"})
def clean_data(data=bauplan.Model("source_data")):
    df = data.to_pandas()
    return df.dropna()

@bauplan.expectation()
@bauplan.python("3.11")
def test_clean_data(data=bauplan.Model("clean_data")):
    return expect_column_no_nulls(data, "id")

Native Python execution. No infrastructure to manage.

Pipelines are ordinary Python and SQL functions. Declare environments and quality checks in code. Execution is managed by the platform.

One control loop for humans and agents

A few predictable primitives for developer and AI agents. Every workflow follows the same loop: branch → run → inspect → merge.

import bauplan

client = bauplan.Client()

dev_branch = client.create_branch(
    branch="fritz.dev",
    from_ref="main",
)

job_state = client.run("./my_project", ref=dev_branch)

if not job_state.success:
    raise Exception(f"{job_state.job_id} failed")

assert client.merge_branch(
    source_ref=dev_branch, 
    into_branch="main"
)