Build Coalesce Pipelines Locally With Your AI Agent

A year ago, data engineers wrote most code by hand. Now, much of it is produced with tools like Claude Code, Cursor, or custom solutions. The impact is real: tasks that once lingered in the backlog can be completed in a day, and one engineer can handle the workload that used to require a team. But with this speed comes a new challenge: more code to review, and the real obstacles now lie in aligning on modeling standards, defining governance, and ensuring accuracy.

Our local development tools (now available in public preview) are built for this new reality. With code generation now fast and inexpensive, the real challenges that remain are the ones that Coalesce has always been built to solve: establishing standards, making key architectural decisions, and validating results at scale. These are best handled by people, so we created a system where your agent handles the generation, while you oversee the important details.

The toolkit includes pipeline files stored in Git, the coa CLI for building and running, Coalesce MCPs for access and administration, platform skills to guide your agent, and Coalesce Desktop-a desktop app that mirrors the Coalesce interface on your machine.

This new suite of tools creates a fast development loop. The best teams typically spin up the initial 70% to 90% of the code with AI coding tools, and then fine-tune the remaining details directly in the Desktop UI for the fastest possible iteration.

We designed our local architecture with four core components:

• Coalesce CLI (coa) - authors, validates, and runs pipelines locally out of your Git repository. It gives your agent a deterministic execution engine to test DDL and DML directly against your data warehouse without routing code through the cloud.
• Coalesce MCP - connects your local agent to your Coalesce workspace, giving it read and administrative access to inspect run histories, monitor job status, add tests, and query deployed environments.
• Coalesce platform skills - a pre-packaged collection of skills available as a Claude Code plugin that teaches your local AI agent best practices for developing and governing data pipelines.
• Coalesce Desktop - a visual interface reading directly from your local workspace files with real-time, bidirectional sync. Developers run their agent in the terminal on one side of the screen and watch live lineage and node updates render visually on the other.

The Local Development Setup Guide walks through how to get started, step by step. If you want to learn more before installing it, you can watch this product deep dive (35 minutes) to see it in action.

Build and run pipelines in code with the Coalesce CLI (coa)

The CLI gives you a code-first way to perform key operations in the Coalesce platform. Your pipeline lives as files in a Git repository, and builds and runs those files directly against your warehouse. This lets you develop locally and enables agents to manage the end-to-end workflow of building, running, and deploying pipelines.

We designed the file format so an agent can treat a pipeline like any other codebase. Source Nodes are YAML. Every other Node is a file in .

A common workflow looks like this:

1. Edit the file
2. to see the generated DDL before anything touches the warehouse
3. to build the table in your development schema
4. to load it
5. Check the result in your SQL client, then repeat

and catch structural and connectivity problems before a run, and executes the full graph in dependency order.

For data engineers building pipelines, you get the Coalesce build experience in your terminal and your editor, working against your own schema, with Git as the source of truth.

For an AI agent, you can think of it as an execution engine where the agent can author code, validate, plan, deploy, and run pipelines from your local workspace.

When the pipeline works, the same CLI promotes it to production, where it becomes visible in the Web app.

Coalesce MCPs give your agent the relevant context

Where the CLI lets you build pipelines using deterministic steps against your local files, MCP lets you go deeper with the ability to stitch different tools together to answer questions such as whether last night's job succeeded, diagnose a failing job, or understand lineage dependencies.

An MCP exposes a set of tools, and each tool is a scoped API call the agent can make on your behalf. The set of tools defines what the agent can and can't do. The Transform, Catalog, and Quality MCPs can pass context between each other, so the same agent can also pull lineage, ownership, and documentation through the Catalog MCP, and monitor status and issue history through the Quality MCP. In practice, that means the agent can check downstream impact before renaming a column, or read a table's incident history before rebuilding it, without you pasting any of that context into the prompt.

You can manage permissions at the user-role level to make sure that less technical users only have read access and don't accidentally delete a production Node. In most cases, viewers or analysts who don't build pipelines will only need the MCP access.

The Coalesce MCPs also chain with the other MCPs your team already runs. A common pattern is for the agent to investigate a Quality anomaly, then post the root cause to the on-call thread through the Slack MCP, or open a ticket in Linear. The data lifecycle work stays in Coalesce, and the communication moves to where your team already is. For a deeper walkthrough of the tools and example prompts, see Hands-On With Coalesce MCPs: Transform, Catalog, and Quality.

Coalesce platform skills teach agents best practices

We have a growing library of skills to build standards such as how data should be modeled, how to rename columns and much more to guide agents on how to do things in the way we recommend, so the same standards are enforced no matter who develops code locally.

A skill is a markdown file (SKILL.md) plus optional supporting files that tell the agent what a task is, which tools to use, what good output looks like, and what to avoid. The repository is a pre-packaged set of these, available as a Claude Code plugin and as plain files for other agents, that encodes how we build pipelines. For example, the coalesce-pipelines skill is the one the agent reads first when it detects a Transform repository. Underneath it sit more specific skills for editing SQL inside Nodes, restructuring the DAG, working with workspace config, publishing to Git, and reviewing risk, plus task recipes such as create-stage-node, add-column, and rename-node-cascade.

Two examples show what that looks like in practice.

• Run the full loop on every change. Validate, dry-run, then create and run, one Node at a time. The dry runs catch Nodes that pass validation but generate no SQL and would silently load nothing.
• Stage before anything else. Every Source gets a Stage Node first, with all columns copied one to one and no logic. Downstream Nodes build on that instead of the raw table.

The rules go down to never reusing an , always referencing upstream Nodes with rather than a hardcoded , and discovering the real node type names in the workspace before naming one. These help make sure that agents follow our recommended standards, and you can even add your own skills if you have more standards specific to your company that you want the agent to take into account.

Coalesce Desktop: review AI-authored work in the interface you already know

While agents are good at creating code fast, in our experience, you'll often still want a human review of the code that's generated. That's what we've built our Desktop app for.

The Desktop app runs locally and mirrors the Coalesce interface with the same graph, same Node views, and nothing new to learn. In a typical workflow, agents do 70% to 90% of the work by creating code that follows Coalesce standards. You then make sure that it's accurate by inspecting dependencies, checking the logic, and catching problems before anything gets committed or deployed.

You can, of course, still use the Web app. Below are some ways that they differ.

Getting started

Local development is available now in public preview. The setup guide takes you from install to a verified workspace in seven steps. A common first step is to open the Desktop app, ask your agent to add a Source Node and run it, and watch it appear. You'll need Git, a Coalesce account, and Snowflake credentials for a development schema. The guide covers the rest.

Talk to us, and we'll help you get set up.