How Stripe Built Kai: Data Dashboards, Reusable Skills, and Enterprise AI Governance

In the world of AI, it’s one thing to build a cool demo, but it's another thing entirely to deploy a system that thousands of employees can use safely and effectively every single day. That's why I was so excited to talk to Sharadh Krishnamurthy, an engineering manager at Stripe, about how his team built Kai), their internal "company brain."

Stripe is an incredibly complex business, and as Sharadh explained, getting AI to everyone wasn't just a technical problem. The real challenge was replicating the governance and context of how the company works at scale. Instead of just handing out raw access to powerful models, they built a custom agent on a foundation of thoughtful infrastructure. The result? Kai is now used by over 86% of the company—that's more than 10,000 people—and is managed by a core team of fewer than 10.

In our conversation, Sharadh gave me a fantastic look under the hood at the specific workflows that make Kai so powerful. We walked through how any employee can create a custom data dashboard, how they can then package that workflow into a reusable "skill" for the rest of the company, and how Stripe uses a concept called "Projects" to create granular, context-aware guardrails. These aren't just abstract ideas; they are concrete solutions to the real-world problems of deploying AI in a large enterprise.

Workflow 1: Creating a Custom Data Dashboard

At a data-centric company like Stripe, everyone needs access to metrics. But building and maintaining dashboards for every possible need is impossible. This is where Kai shines. Sharadh showed me how he could ask Kai to generate a dashboard on the fly.

The Initial Prompt

The process starts with a simple, natural language request. To see how Kai itself was performing, Sharadh prompted it:

"Hey, go find these queries that I usually use to track Kai adoption, and I want you to like create a dashboard for me."

How Kai Tackles the Request

Immediately, Kai gets to work. It's not just blindly sending this to an LLM. It first identifies the right tool for the job, in this case, a skill called Ask Data. This skill is specifically designed to query Stripe's internal data systems.

Everything happens in a secure, per-session cloud sandbox, which means my session and Sharadh’s session are completely isolated. This is crucial for security. The Ask Data skill then intelligently queries their data ecosystem, which includes their internal query layer, Hubble), and their Trino data warehouse.

What I found fascinating was the three-layer triage system the agent uses to find the right data:

1. Look for existing reports: First, it tries to find an existing dashboard or artifact that already answers the question.
2. Use the analytics layer: If that fails, it consults a "blessed" analytics layer with key, vetted business metrics.
3. Query the data catalog: As a last resort, it will go to the full data catalog to find the right tables and write a brand new SQL query.

This tiered approach, built for humans, works brilliantly for agents. It also underscores a key lesson: your data warehouse has to be incredibly resilient. As Sharadh noted, "when in doubt, an agent will just brute force it," so your infrastructure must be hardened against high-volume queries.

The Result: An Interactive Dashboard

In just a few moments, Kai produced a beautiful, interactive dashboard showing Kai's adoption rate across the company. It was even styled with Stripe's signature "blurple" color.

But the real power is in collaboration. This isn't a fire-and-forget process. Sharadh then asked Kai to iterate on the dashboard.

"Hey, I love this dashboard, but let's do some more here and... Use this query, get a breakdown..."

Kai took the new instructions, re-ran the query, and updated the existing dashboard to include a breakdown of adoption by team. This ability to do "last mile" data analysis allows non-engineers to create their own lightweight, hyper-specific apps and reports without filing a ticket.

Workflow 2: From One-Off Task to Reusable Skill

Creating a dashboard once is useful. But what if your whole team needs to see that same report every week? The next workflow Sharadh showed me was how Kai can turn a successful session into a reusable, load-bearing workflow.

The Skill-Creator Skill

Instead of having to remember the prompt or copy-paste the code, Sharadh simply asked Kai to package the session into a new skill. Kai has a "skill-creator skill" that analyzes the conversation history—the prompts, the tools used, the code generated—and synthesizes it into a standardized, open-spec skill definition.

Kai presents this in a slick, IDE-like editor where the user can review the skill's name, description, and the trigger phrases that will invoke it. This empowers anyone in the company, not just engineers, to contribute to the automation library.

The Magic of Skill Retrieval

Once the skill was saved, the magic happened. Sharadh opened a new session and simply typed:

"Give me the latest Kai Adoption Dashboard"

Kai instantly recognized this phrase, retrieved the new skill we had just created, and executed the entire workflow to generate the dashboard again.

This is a huge deal in an enterprise setting. Unlike a developer's machine where a folder structure provides context, an enterprise user's context is fluid. Stripe has invested heavily in a sophisticated retrieval system that can find the right skill from a library of over 2,000, based purely on user intent.

Managing Skills at Scale

Of course, with 2,000 skills, quality and maintenance become a challenge. Sharadh explained that they have robust telemetry to see which skills are being used heavily and which are not. The platform can automatically suggest improvements to skill authors and has a deprecation policy to prune unused skills, ensuring the library remains relevant and doesn't bloat the agent's context.

Workflow 3: Enterprise-Grade Governance with "Projects"

This all sounds great, but how do you prevent an agent from going rogue and, as Sharadh put it, "creatively bringing your infra down"? Stripe's answer is a brilliant concept called "Projects."

A Project in Kai is much more than a chat folder. It's a powerful governance layer that allows a designated owner (a DRI, or Directly Responsible Individual) to define the rules of engagement for a specific workflow, team, or initiative.

Project-Based Controls

Within a project's settings, the owner can configure:

• Default Models: To manage cost and performance, you can specify that a project should default to a cheaper, faster model like Claude Code instead of a more expensive one.
• Scoped Skill Sets: You can limit the available skills to only those relevant to the project's purpose.
• Custom Backends: A team can even bring their own bespoke agent or harness and run it behind the standard Kai interface, leveraging all the same governance features.

Human-in-the-Loop with Tool Policies

The most powerful example of this is setting tool policies. Sharadh described a use case for the HR team, which deals with highly sensitive data. You don't want an agent accidentally sharing private information to a public Google Drive folder.

To demonstrate, Sharadh configured our demo project to require human approval for the Google Calendar tool. He then prompted Kai:

Create a calendar invite for me and Huang tomorrow at 11 AM Pacific

Instead of just running the command, Kai stopped and presented a confirmation dialog, asking for explicit permission to use the calendar tool.

This is what Sharadh calls "appropriate friction." It moves the burden of security from the end-user needing to remember rules to the platform itself, which enforces context-specific policies. You don't get annoying pop-ups for every action, only for those deemed sensitive within the context of the project you're working in.

Putting It All Together

What the Stripe team has built with Kai is a masterclass in enterprise AI. The three workflows—creating data dashboards, packaging them into reusable skills, and governing everything with Projects—show a deep understanding of what it takes to make AI work at scale. It’s a system that empowers employees while giving the company the control and safety it needs.

The secret sauce isn't just a powerful model; it's the years of pre-AI investment in developer experience, a resilient data platform, and clear API boundaries. These foundations gave Stripe the leverage to build a system that is both incredibly powerful and thoughtfully governed.

As you think about building AI tools for your own company, I hope you take inspiration from this layered approach. Start with empowering users, but build the rails for reusability and governance from day one. It’s how you go from a cool hack to a truly transformative internal product.

---

Thank you to our sponsors!

• DX: DX tracks speed, quality, and cost together across the software development life cycle, giving engineering leaders clear visibility into how AI impacts delivery and whether those investments are translating into real value. Download the full report at getdx.com/howiAI.
• Hyperagent: Hyperagent is the platform for deploying always-on agents that actually run your business. Build agents in the cloud and deploy them where your work already happens, like Slack, Telegram, or email. How I AI listeners get a hundred dollars in free inference to start building. Claim yours at hyperagent.com/howiai.

---

Episode Links

Where to find Sharadh Krishnamurthy:

• Stripe Careers

Where to find Claire Vo:

• ChatPRD
• Website
• LinkedIn
• X (formerly Twitter)