AivexaNewsSearch
AI news for builders and product teamsChecked every hour

How Stripe Built Kai on Deep Agents in 1 Week

Collected Nov 9, 2026

Stripe's AI platform team has published an account of how it built Kai, the company's Knowledge AI Platform and internal productivity agent, on LangChain, LangGraph and the open-source Deep Agents agent harness. Anupam Upadhyay, a staff software engineer, built the initial version in a single week; Sharadh Krishnamurthy, engineering manager for Stripe's Agent Foundation team, led the effort alongside him. Stripe says the product hit its quarterly adoption target within a week of entering open preview and grew more than 16x, from 296 users to over 5,000, in roughly four weeks.

Kai is intended for the work most employees actually do: synthesizing data, brainstorming, drafting documents and analyzing trends. It runs as a session-based chat interface connected to Stripe's internal data warehouse, Slack and Google Suite. As a conversation continues, the agent produces artifacts such as reports, dashboards and documents that live alongside the chat and evolve with it, which the team describes as a coding agent for non-engineers. Generic assistants require users to explain their context each time; Kai ships with Stripe-specific tools and skills so it already understands internal systems, data sources and norms. Domain knowledge comes from a federated library of more than 1,000 skills contributed by over 100 teams.

The origin was a shift in direction. After Claude Code launched in late 2024, demand to build agents spread across Stripe, but non-engineers hit barriers around the terminal, data access and security. Krishnamurthy and Upadhyay reasoned that instead of pushing those employees toward developer tooling, Stripe could meet them with something purpose-built, framed as an always-on, production-ready assistant.

The architecture has four layers. Deep Agents sits at the base, handling LLM interaction primitives such as request management, agent execution and middleware composition. Above it, a Stripe-specific harness integrates the agent with the company's security posture, infrastructure and internal services. A configuration layer then lets teams define custom Kai agents with different skill sets, behaviors and personas without touching the harness, and the Kai UI is the product experience connecting down through all three. Krishnamurthy's framing is that the Deep Agents layer covers the generic problems so the team can focus on Stripe-specific agent problems.

Three pieces of middleware made the fast build possible. The first is a filesystem: Kai runs as a cloud service rather than a local process, so Stripe built a virtual filesystem backed by S3 where agents read, write and reference files across turns. In practice this gives the model persistent context it can inspect, update and organize over a session. Each sandbox call uses a sync in/sync out pattern, materializing relevant files into the sandbox before execution and syncing new or modified files back afterward. The second is a sandbox for two kinds of work, running Python analytics to query data and produce charts, and processing arbitrary file formats such as PDFs, presentations and structured documents. Notably, the sandbox is exposed to the agent as a tool rather than being its execution environment, so LLM-generated code runs in a separate boundary. That is a sensible security trade-off: it limits what generated code can touch, at the cost of extra plumbing to move state in and out. The third is summarization middleware, which keeps long multi-turn sessions within context limits and manages cost; Stripe tunes summarization threshold, summarizer model and output size, and notes that because most users run sessions intermittently, avoiding cache misses on large contexts matters for spend.

Skill selection is where the design gets interesting. Stripe reports 500-plus internal MCP tools, so loading everything into context is not viable. Skills in Deep Agents are structured, agent-executable modules that specify how to accomplish a task, which tools to load and how to approach a category of work. Stripe uses a two-pass system in which skill selection gates tool loading, driven by allowedTools lists, so the model first decides which skills are relevant and only then pulls in their tools. Some foundational skills are pinned regardless of what the model loads or unloads, which keeps Stripe context and policy behavior consistent. Skills are also tiered by user profile, so a sales ops employee sees a different set than someone in finance, with the option to add more.

The team is candid about limits. It found quality degradation in frontier models once more than 150 skills were combined with the system prompt under a 1,024-character frontmatter cap, and skill count remains an open challenge. For scale, Stripe is building a hybrid selection system: LLM-only selection works well now and beats retrieval when full context fits, but a retrieval or classifier layer will be needed to prefilter the catalog before the model makes final calls. Other roadmap items include governance and compliance guardrails as adoption spreads, automatic behavior adaptation so users do not tune settings themselves, and eventually shared skills, shared artifacts and collaborative sessions; today's model is single-user.

Kai also validated a language bet. Stripe spent over a decade building tooling, security and deployment support around Ruby and Java, and moving to a Python-native stack meant rebuilding internal scaffolding. The one-week build demonstrated the return.

Adoption skewed toward exactly the roles the team targeted. Stripe says 83% of the company uses Kai weekly across more than 60,000 sessions, with higher percentage adoption in business functions such as Marketing at 95% and go-to-market teams at 87% than in engineering. Users describe it as useful for deal preparation, pulling data from multiple internal sources, and for finance analysis and dashboard generation, and new hires use it for onboarding. Engineers, despite the non-engineer target, use it to answer questions about their own systems and to inspect traces and usage data for coverage gaps.

Why it matters: for teams building internal agents, the concrete lessons are that an open harness can absorb generic infrastructure, that gating a large tool catalog through skills beats loading tools upfront, and that sandboxing generated code as a callable tool rather than as the agent's runtime is a workable security pattern. The adoption numbers suggest non-engineers are a larger addressable audience than developer tooling reaches, and the reported 150-skill degradation threshold is a practical ceiling worth testing against your own prompts. The open questions are scaling skill selection and adding oversight without reintroducing the configuration burden Kai was built to remove.

Read at LangChain

Based on reporting from the original publisher. Visit the source for full context and later updates.

Publisher excerpt

Learn how Stripe built Kai, a company-wide AI agent on LangChain, LangGraph, and Deep Agents, reaching 5,000 users in roughly 4 weeks.