How Terracon Is Using The Alation AI Agent SDK To Make Governance Stick

At Terracon, data governance presents a unique challenge: we're a 100% employee-owned consulting engineering firm with more than 7,000 employees distributed across 200 U.S. offices. We provide geotechnical, environmental, construction materials, and facilities consulting services that support infrastructure, industrial, commercial, and energy projects nationwide. That geographic distribution, combined with the diversity of our technical specialties, creates a complex data landscape—304 different data systems, to be exact. And my team? We're three people.

The scale is daunting and complex. But what makes it even more challenging is that we're not operating in a vacuum. Right now, Terracon is in the middle of a massive ERP transformation effort. Business transformation, system migrations, new processes—everyone has a lot on their plate.

But here's what many data leaders might miss: an ERP transformation is also an enormous opportunity. It's a moment when the entire organization is already focused on data—how it flows, where it lives, what it means. People are asking questions about data quality, data definitions, and data access. That creates a rare opening for governance to become not just another initiative, but an essential part of how the business operates.

As Director of Data Governance at Terracon, my mission is to build a foundation that supports not just this transformation, but everything around data currently occurring and that which comes after. And Alation's AI Agent SDK has become key to that effort—helping us meet the scale challenge head-on and turn governance into something people actually want to engage with.

Scaling with AI 

The operational reality is that Terracon is a consulting engineering company. Everyone I’ve talked to and worked with understands the importance of data, but they are inundated with communications, new technologies, and new processes.

That reality forced us to think differently. We needed automation that didn’t just accelerate our work—it had to amplify our impact and make it effortless for end clients (our users)  to engage with us, with Alation, and with the broader concept of treating data as an asset. To achieve this, we needed to embed governance directly into the tools our people already use, rather than asking them to adopt yet another platform during an already overwhelming transformation.

This is where the AI Agent SDK became a force multiplier for us. It's allowed us to scale governance work—creating the first pass at metadata and glossary population (because people work better with something in front of them rather than a blank slate). We also use it for enriching metadata and surfacing trusted data—without adding headcount. Instead of being limited by staffing, we can now embed intelligence into our users' existing workflows and tackle challenges that would have been impossible with spreadsheets, meetings, or email campaigns alone.

Curiosity was the spark

Our journey with the SDK didn't start with a 50-slide strategy deck or a formal RFP. It started with curiosity—and a very cool intern: Nitin Ankareddy.

I handed him some governance tasks that we needed, but also asked him, “What are you interested in working on that can help?” To my surprise, he said: "This data governance stuff is really cool. But I really want to do something with AI."

So we let him explore. The AI Agent SDK is a developer toolkit that enables teams to build custom AI agents that can read from and write to the Alation Data Catalog. It integrates with frameworks like LangChain and Anthropic's Model Context Protocol, allowing developers to create agents tailored to specific use cases—whether that's enriching metadata with local knowledge sources, creating a semantic layer, or surfacing governed data inside the tools where people work.

The SDK includes bulk retrieval tools for pulling metadata at scale, natural language interfaces for intuitive interaction, and flexible integration options that let you connect Alation with other AI systems. 

My intern dove into the GitHub repository—which, by the way, is one of the best I've ever seen—and started experimenting. Before long, he showed me a prototype where Alation metadata was flowing directly into Microsoft Co-Pilot prompts. That was the "aha moment."

Suddenly, governance wasn’t something people had to remember to do. It wasn’t a separate system they had to log into. It was just there—surfacing trusted data definitions and context right inside the tools they already used every day.

That spark of curiosity changed everything. Instead of governance being a distant, compliance-driven process, it began directly influencing how people worked. It showed up in every Co-Pilot interaction, guiding users toward relevant, trusted information instead of inaccurate or incomplete data. In other words, governed data became the reason Co-Pilot users could make confident, data-driven decisions—right when and where they needed to.

Meeting users where they already work

Here's the hard truth about data catalogs: if you build it, they won't necessarily come.

At Terracon, employees live inside Microsoft 365, Teams, and increasingly, Co-Pilot. They're busy delivering projects, responding to clients, and managing the ERP transformation. Asking them to step out of those tools to log in and perform an action in a catalog? It is an ask to make this happen, no matter how many communications we send out or how great our intranet page looks.

So we flipped the approach. Instead of asking users to come to governance, we brought governance to them. We needed to meet them where they are, and the SDK has given us the flexibility to build integrations that meet people in their workflow. Business users encounter Alation-powered answers inside Co-Pilot. 

The immediate value is simple: people get the answers they need faster, with less friction. They don't have to hunt for definitions or wonder which data source to trust. The information is already there when they need it.

But the long-term business value goes deeper. When governance becomes invisible—embedded seamlessly into daily workflows—it builds trust. People start to rely on the metadata they see. They start to correct it when it's wrong. They start to own it. And that's when governance becomes self-sustaining.

This is the core insight: governance adoption isn't about pushing people into a catalog. It's about bringing the catalog into their daily flow of work.

Putting governance into Co-Pilot

The most powerful thing we've done is embed Alation directly into Co-Pilot prompts. Every time someone at Terracon asks Co-Pilot a question, our metadata can ride along with the response.

Here's what that looks like in practice: A geotechnical engineer asks Co-Pilot, "What is an aquifer?" Co-Pilot returns a general definition—a substratum of geology that catches and stores water, primarily used for drinking water. That's useful. But then, without any additional prompting, Co-Pilot also surfaces information from Alation about Terracon's specific aquifer data layers, including which systems (like Pivvot) contain that data and how it's structured. That’s game-changing.

One approach is to use the Model Context Protocol (MCP) to make this happen. Think of MCP as a framework that allows AI systems to access multiple knowledge sources—like calling different friends for different types of expertise. One "friend" might be Wikipedia for general knowledge. Another might be your M365 environment for internal documents. And now, Alation is another friend—one that knows exactly what data you have, where it lives, and who's responsible for it. (A second approach is to build a Microsoft Co-Pilot agent that is tuned to specifically ask, not only questions of M365, but also directly of Alation.)

This approach turns governance from "another place to go" into "part of how I work." And it aligns perfectly with one of our corporate values: curiosity. If we can spark curiosity inside the tools our people already use, we lower the barriers to engagement dramatically. People start asking, "What else does Alation know?" instead of wondering why they should bother logging in.

That's governance becoming sticky. Not through mandates or training sessions—but through usefulness.

The role of synthetic metadata

One of the biggest hurdles in any governance program is metadata capture. No one wants to fill out endless column descriptions across hundreds of tables. How do we magnify the work of the 3 people on our team and make it seem like 30?

That's where synthetic metadata came in. Using the SDK, we can generate draft descriptions for columns and tables based on knowledge sources like PDFs, SharePoint files, or intranet content. We feed the agent documents from Terracon's decades of technical expertise, and it creates contextually relevant descriptions that reflect our business—not generic definitions you'd find in a textbook.

Here's the clever part: these descriptions aren't always perfect. And that's by design.

When an engineer sees a description that isn't quite right, they're motivated to fix it. It's much easier to correct something that's 80% accurate than to stare at a blank field and write a description from scratch. And when they make that correction, they become the owner of that metadata. Suddenly, they've moved from passive consumers to active stewards—without us ever having to ask them to "volunteer as a data steward."

This is both a tactical win and a strategic one. Synthetic metadata accelerates coverage, seeds the catalog with usable content, and nudges people into stewardship. It creates an on-ramp to governance that feels engaging rather than overwhelming.

For other organizations, my advice is: don't wait until you have the perfect metadata strategy. Use synthetic metadata as a conversation starter. Get something in front of your users, and let their feedback and corrections become part of the governance process. You'll be surprised how quickly people engage when they're reacting rather than creating from scratch.

How we enrich metadata in practice

Our enrichment process combines the SDK’s flexibility with Terracon’s own institutional knowledge. Here’s what it looks like in practice:

1. Pull metadata from Alation by connecting to a data source, which will automatically populate the schemas, tables, and columns.

2. Ask the agent to create metadata with local knowledge sources—things like emails, PDFs, SharePoint libraries, or Confluence pages contained in M365. For a consulting firm like ours, this context is critical; generic metadata definitions won’t resonate with engineers in the field.. For example, I might prompt it: “For each column, generate a title and description under 30 words, using relevant context from these documents.”

3. Refine the outputs. The SDK allows me to experiment. I can ask it to provide three variations, then choose the most appropriate style—whether narrative, structured, or bullet-point. I can also set parameters like word limits or business use cases.

4. Review the final product with the experts and owners. Together, we verify that the generated metadata accurately reflects real-world usage and aligns with organizational standards.

5. Export and bulk upload the enriched metadata back into Alation, ready for the final review/approval process. The review step is key: it gives stewards the chance to validate and adjust the AI-generated content before it becomes “official.” The approval step validates that what we are representing in Alation is “Gold”. 

The beauty of this approach is that it blends automation with human oversight. We get speed and coverage without sacrificing trust. And because the SDK is framework-agnostic, we can combine it with tools like LangChain or Anthropic’s model context protocol as our needs evolve. 

But here's the higher-order value: enriched metadata isn't just about making your catalog look complete. It provides the foundation for data quality tracking and monitoring by surfacing attributes like timeliness, source, lineage, and popularity. For AI use cases specifically, well-documented metadata helps models understand context, which dramatically improves accuracy and reduces hallucinations. When an AI agent knows where data comes from, how fresh it is, and what it's meant to represent, it can make better recommendations and avoid confidently wrong answers.

For practitioners, the lesson is this: enrichment doesn’t have to be a slog. With the SDK, you can move quickly, involve your business context, and still maintain governance standards.

Making it stick

As I’d mentioned, two of our core values at Terracon are curiosity and courage. That's what I love most about this journey. By using the AI Agent SDK, we're not forcing governance on people—we're making them curious about it and courageous about becoming involved in the governance journey and speaking up if they think something can be improved. 

We're showing them metadata in the flow of their work. We're giving them something to react to and improve. And we're proving that even a team of three can start to shift culture across a 7,000-person company.

It hasn't been a perfectly planned strategy. Some of this has been happenstance—an intern's enthusiasm, a timely ERP transformation, and a toolkit that arrived at exactly the right moment. But that's often how the best innovations happen: not through 50-slide decks, but through curiosity, experimentation, and a willingness to meet users where they are.

For us, the Alation AI Agent SDK isn't just a toolkit. It's how we scale with limited resources, meet users where they are, and make governance stick—not through compliance but through usefulness.

And in a world where data governance often feels like an uphill climb, that's the kind of approach that actually works.

Curious to learn more? Explore the AI Agent SDK today – or, reach out to me on LinkedIn.