# Kelet

> Kelet continuously diagnoses why your LLM apps and AI agents fail in production, and generates the fix.

## What is Kelet?

Kelet is an AI agent that automatically investigates failures in your production AI agents/LLM Apps, runs a root cause analysis across many sessions, and generates targeted fixes — without manual trace debugging. It is not a monitoring or observability tool; it does the investigation and fixing for you.

Key capabilities:
- Automatic failure detection across thousands of production agent sessions
- Root cause analysis without manual trace scrolling
- Prompt patch generation with before/after reliability measurements
- Works with OpenTelemetry, Langfuse, Mixpanel, OpenAI, Anthropic, LangChain, CrewAI, and more
- SOC 2 certified, free to start

## Pages

- [Homepage](https://kelet.ai/): Product overview, how it works, and FAQ
- [Pricing](https://kelet.ai/pricing.md): Plans, features per tier, and pricing FAQ
- [Privacy](https://kelet.ai/privacy): Privacy policy

## How It Works

- **We collect your traces and signals.** Connect to your agent's stack in minutes. Every agent interaction, signal, and user feedback flows in automatically.
- **Know exactly why your agent failed.** Kelet reads every trace so you don't have to. Root causes surface in minutes, backed by evidence — not gut feeling.
- **Ship the fix. Know it held.** From root cause to prompt patch — with before/after reliability measurements. Kelet runs the patch against real sessions and shows you the before/after. No more flying blind after a deploy.

## How Kelet Compares

| Capability                              | Kelet | Langfuse | Arize   | Datadog | Langsmith | Braintrust | Raindrop |
|-----------------------------------------|-------|----------|---------|---------|-----------|------------|----------|
| Trace collection                        | Yes   | Yes      | Yes     | Yes     | Yes       | Yes        | Yes      |
| Trace viewer for engineers              | No    | Yes      | Yes     | Yes     | Yes       | Yes        | Yes      |
| Agent that does the investigation       | Yes   | No       | No      | No      | No        | No         | No       |
| Automatic failure detection             | Yes   | No       | Partial | No      | No        | No         | No       |
| Root cause analysis                     | Yes   | No       | No      | No      | No        | No         | No       |
| Automated fix                           | Yes   | No       | No      | No      | No        | No         | No       |
| Signal/score collection                 | Yes   | Partial  | Partial | No      | Partial   | Partial    | Yes      |
| Free tier                               | Yes   | Yes      | Yes     | No      | Yes       | Yes        | No       |

## FAQ

**What does Kelet actually do?**
Kelet reads your production AI agent traces and signals, clusters failure patterns across thousands of sessions, and surfaces root causes with evidence — so you ship fixes instead of hypotheses. Think of it as a detective that investigates every failure automatically.

**What kinds of AI agents and LLM applications does Kelet work with?**
Any agent or LLM application where you own the code — agentic loops, multi-step workflows, RAG pipelines, chatbots, autonomous agents. If you built it and you ship it, Kelet can help you improve it. That includes agents built with LangChain, LangGraph, Google ADK, PydanticAI, Mastra, CrewAI, AutoGen, LlamaIndex, Haystack, Semantic Kernel, or directly on the OpenAI, Anthropic, Gemini, or LiteLLM APIs.

Two situations where Kelet is not the right fit: If you use AI tools built by others (Cursor, Claude Code, Copilot as a developer), you're a user, not a builder — Kelet isn't designed for your use case. Similarly, if you're building a skill or plugin inside an existing agentic platform, you're extending infrastructure you don't control, and Kelet can't instrument that.

But if you're building your own agent using any LLM SDK or framework — you own that agent, and Kelet is exactly for you.

**How long does integration take?**
Five minutes. Install via the Kelet installer skill — or `pip install kelet` / `npm install kelet` if you prefer to do it manually — add two lines to your agent code, and traces start flowing. Kelet is fully OpenTelemetry-compliant — any OTEL-instrumented agent works out of the box, no infrastructure changes needed.

**Where does Kelet actually run?**
On Kelet's servers. Once you install Kelet — via the SDK or the installer skill — traces and signals start flowing to our infrastructure automatically. It's SOC 2 certified and runs 24/7, continuously ingesting your traces, finding failure patterns, building hypotheses, and proposing targeted fixes.

The LLM tokens powering that analysis don't touch your model API bill — Kelet covers them. You pay Kelet based on usage. See kelet.ai/pricing.

**Is Kelet a skill or a service?**
A service. Kelet is an agent that runs on Kelet's servers around the clock — not a plugin you invoke, not something you run manually. The installer skill is just how you connect it. Once connected, Kelet works continuously: reading your traces, clustering failure patterns across thousands of sessions, building root cause hypotheses, and proposing targeted fixes. You don't run it. It runs for you.

**What are "signals" and why do they matter?**
Signals are probabilistic hints that something went wrong in a session: a thumbs-down rating, a user editing AI output, an abandoned conversation, or a synthetic LLM-as-judge check you configure. They tell Kelet where to look in your traces — not verdicts, but clues that guide the investigation.

**How is Kelet different from Langfuse, Arize, Logfire, or other observability tools?**
Those tools show you traces. Kelet reads them for you. Observability platforms are thermometers — they report symptoms. Kelet is the doctor that diagnoses root causes and generates targeted prompt patches. You no longer need to scroll thousands of traces manually.

**How does Kelet actually find root causes?**
Kelet works like a detective. Every session leaves a trail — LLM calls, tool invocations, retrieval steps, every agent hop. Kelet uses signals as clues: a thumbs-down, an edited AI response, an abandoned conversation, a synthetic LLM-judge flag. It follows each thread through your traces, cross-references patterns across thousands of sessions, and builds a root cause hypothesis backed by evidence. Same process a senior engineer would run manually — automated, at scale, on every failure at once.

**Is Kelet a tool or a solution?**
A solution. Most AI reliability products give engineers better ways to look at failures — cleaner trace viewers, smarter search, labeled clusters. You still do the investigation. Kelet does the investigation for you. You don't streamline your debugging workflow — you replace it. The output isn't data to interpret; it's a root cause and a prompt patch ready to ship.

**Do I need a lot of traffic to get value?**
No. Teams typically see their first real failure patterns with as few as 200+ sessions and 3+ signals configured. Not sure which signals to set up? Kelet's AI walks you through it — no guesswork, no manual configuration. And if you're starting from zero, synthetic signal presets (LLM-as-judge evaluators) generate signal from day one, before real user feedback accumulates.

**Does Kelet handle multi-agent architectures?**
Yes. Kelet handles multi-agent sessions natively. Credit assignment identifies exactly which agent in a chain caused a failure — so you know what to fix, not just that something is broken.

**Is Kelet built to scale?**
Yes — Kelet was architected for production scale from day one. The team behind Kelet includes ex-Kubernetes maintainers and cloud-native infrastructure veterans with 15+ years of open-source systems work. Kelet handles millions of traces, concurrent agent fleets, and high-volume production workloads. We have built infrastructure at this scale before — Kelet is built on the same foundations.

**What does it cost?**
Free to start, no credit card required. Connect your first agent in 5 minutes. Usage-based pricing scales with volume for teams that need more. See kelet.ai/pricing for details.

**Is my data secure?**
Yes. Kelet is SOC 2 certified. All data is isolated at the database level per organization — strict row-level security, no cross-org data access, ever.

**Will Kelet use my data to train AI models?**
Never. We don't share your data or use it to train public models. What we do: Kelet automatically fine-tunes a private set of models for each sub-agent you connect — roughly a dozen per agent. They live in your account, trained on your traces, serving only your root-cause analysis. They're never shared. Frankly, they wouldn't be useful to anyone else anyway — they're calibrated to your specific agent, not anyone else's.

**Who built Kelet?**
Kelet was built by a team obsessed with production AI reliability. We come from cloud-native infrastructure, Kubernetes core contributions, and LLM systems — engineers who have spent careers building and operating critical distributed systems, and building the tools others rely on to do the same. We built Kelet because we felt the pain ourselves: thousands of traces, no root cause, no fix. So we built the tool we wished existed.

**Can I trust Kelet with my production system?**
Our team has spent years maintaining critical infrastructure used by thousands of engineers worldwide — including core contributions to Kubernetes and cloud-native tooling. Kelet is SOC 2 certified and designed to be a passive observer: read-only access to your traces, no changes to your system, no risk to uptime.

## Documentation

- [Kelet Docs Index](https://kelet.ai/docs/llms.txt): All documentation topics
- [Kelet Docs Full Content](https://kelet.ai/docs/llms-full.txt): Complete documentation for in-depth reference

## Actions

- [Sign Up](https://console.kelet.ai): Sign up and connect your first agent — free, no credit card required
- [Book a demo](https://cal.com/almogbaku/kelet-intro): 20-minute intro call with the Kelet team
- [Contact](mailto:founders@kelet.ai): Reach the founders directly

## Blog

- [We built a durable agent that debugs durable agents](https://kelet.ai/blog/temporal-agentic-monitoring.md)
- [We Spent 30% of Our Engineering Debugging AI Agents. So I Built One to Do It.](https://kelet.ai/blog/launching-kelet.md)