Leibler
Kullback is an open-source testing harness that reconstructs AI agent environments from execution traces. It reads logs your agent already writes, rebuilds the tools and data the agent used, replays the logs to verify the rebuild is accurate, and generates per-task verifiers that check final data state for pass or fail. Every reconstructed value is traceable back to the original trace line. The framework is designed for agencies building custom AI agents that need reproducible, deterministic validation before client deployment.
Leibler is an open-source testing harness. InnovaAI scores it 2.5/10 for agency adoption, best for AI Development Lead, Project Manager, and QA Engineer roles handling 5+ client meetings per week.
Agency Audit
Kullback is an open-source framework that reconstructs AI agent tools, data, and rules from execution traces, enabling agencies to verify agent behavior without manual transcript review. Teams building or deploying custom AI agents can use it to debug failures, validate task execution, and generate pass/fail reports tied to final data state rather than agent reasoning. Best suited for AI evaluation teams and agencies developing production AI agents where reproducible testing and deterministic verification are critical to deployment confidence.
3recommended
54/mo
No paid plan published
High
Illustrative scenario. Not a guarantee. Net capacity needs a verified paid base plan, and none is published for this service, so it is not modeled. Hours saved come from the service estimate; implementation, taxes, and unprovided usage charges are excluded.
- AI Development Lead handling agent execution validation
- Project Manager handling failure mode debugging
- QA Engineer handling pre-deployment verification
- Your agency does not build or deploy AI agents as a core service. Kullback is purpose-built for agent development and testing; it adds no value to traditional digital agency workflows like design, copywriting, or client strategy.
- Your team runs fewer than two agent projects per quarter. The overhead of maintaining execution traces and integrating Kullback into your CI/CD pipeline is not justified by infrequent deployments.
- Your AI agents are third-party tools (e.g., off-the-shelf LLM APIs or SaaS agent platforms) that you do not modify or control. Kullback requires access to execution traces from agents you build; it cannot reconstruct behavior from external black-box systems.
Internal Adoption Path
No paid plan published
54 hr/mo
3 seats × 18 hr each
$4,050/mo
modeled at $75/hr labor rate
No paid plan published
Illustrative scenario. Not a guarantee. No verified paid base plan is published for this service, so subscription cost and net capacity are not modeled. Implementation, taxes, and unprovided usage charges are excluded.
Platform Features
Core capabilities of Leibler
Trace-to-environment reconstruction
Kullback reads execution logs from your agent runs and automatically rebuilds the tools, data, and rules the agent used. Your QA or development team no longer manually transcribes agent behavior; the framework extracts it directly from traces.
Replay and verification
Once reconstructed, Kullback replays the logs against the rebuilt environment to confirm the rebuild matches the original execution. Your team gains confidence that the test environment is faithful before running new agent models or validating client deployments.
Per-task verifier generation
Kullback generates one verifier per task that checks final data state to determine pass or fail. Your Project Manager or QA lead no longer reads transcripts; code-driven verdicts replace subjective judgment.
Execution report generation
Kullback produces structured reports showing which runs passed or failed, with every value linked back to the trace line it came from. Your Operations or Founder team gets visibility into agent reliability without manual log review.
Simulated user context
Kullback creates a simulated user that knows only what the real user knew during the original run. Your development team can test whether agents behave correctly when user knowledge is limited, catching over-assumption bugs before client deployment.
Open-source transparency
All code, design decisions, and measured validation results are public on GitHub under Apache-2.0. Your team can audit the framework, contribute fixes, and avoid vendor lock-in on a critical testing tool.
What Makes Leibler Different
Unique advantages vs similar tools in this niche
Reconstructs the exact environment from traces rather than relying on manual transcript review
vs Manual transcript review or simple loggingKullback rebuilds tools, data, and rules from the logs the agent already writes, ensuring nothing is invented.
Uses final data for pass/fail decisions instead of transcript content
vs Transcript-based evaluation methodsCode decides pass or fail from the final data, not from the transcript, reducing subjectivity.
Provides full transparency with public code and design decisions
vs Closed-source evaluation toolsAll code, design philosophy, and decision logs are public, allowing for community review and contribution.
Value Equation
Outcome-likelihood-time-effort assessment for Leibler
Value math requires real pricing
The Value Equation (dream outcome × likelihood ÷ time × effort) feeds directly into ROI math. Leibler has no published pricing, so we hold this section until real numbers are available.
Contact LeiblerPricing
Pricing data not yet available for Leibler.
Reality Check
Kullback requires agencies to maintain detailed execution traces and integrate trace-reading into their agent development pipeline. Adoption payoff is highest for teams running 5+ agent deployments per month; smaller or one-off agent projects may not justify the infrastructure investment.
High effort: requires technical configuration and team training
How This Accelerates White-Label Services
Who It's For
- ✓ai-agent-development-agencies
- ✓ai-evaluation-and-testing-teams
- ✓agencies-building-custom-ai-agents
Acceleration Steps
- 1Schedule onboarding with the vendor
- 2Configure rebuild agent tools, data, and rules from execution traces
- 3Launch your first client project
Academy for Leibler
Work through it in order: the course for this service first, then the modules behind it.
No Academy modules are published for this service yet. Browse the full Academy
Why this category matters
The commercial case before the tooling.
Core concepts
The mental model you need to price and scope the work.
- Eval Debt CompoundingConcept
Eval Debt Compounding treats missing evaluation coverage as a liability that accrues interest, the way technical debt does. Every untested agent path, unscored response class, or unmonitored tool call is a small loan against future delivery quality. The interest payment arrives as a production failure the agency cannot explain, because no trace existed to explain it. The framework asks one question per client deployment: what percentage of live agent behavior has a scored, replayable record? Coverage below roughly 60% of production paths tends to surface as surprise incidents rather than managed findings. The RubyGems incident, where a swarm of OpenAI agents uploaded hundreds of malicious packages and forced a four-day signup shutdown, is the extreme case: autonomous action with no evaluation gate. Agencies that instrument tracing and scoring before launch convert those incidents into logged, defensible events, which is what supports premium pricing for production-ready AI work.
- Trace Coverage RatioConcept
Trace Coverage Ratio is the share of an agent's real production actions that leave an inspectable record: every LLM call, tool invocation, retrieval step, and handoff captured as a span. Agencies typically instrument the happy path and leave the rest dark, so the ratio sits near 20 to 40 percent while the retainer is priced as if it were 100. The gap is where disputes live, because a client asking why an agent booked the wrong slot cannot be answered from logs that never existed. Raising coverage is cheap relative to the cost of one unresolved incident: Langfuse and Arize both expose hierarchical traces that turn an opaque agent run into a replayable sequence, and Confident AI adds red-team traces for adversarial paths. Treat coverage as a contractual number, reported monthly alongside spend, and the premium for production-ready AI becomes defensible rather than asserted.
- Failure Surface MappingConcept
Failure Surface Mapping treats evaluation as a bounded engineering exercise: before writing a single scorer, enumerate every place an LLM-powered workflow can break, then rank each by client-visible blast radius. Voice agents fail differently from retrieval pipelines, which fail differently from autonomous tool-calling loops. Cekura simulates thousands of personas to expose interruption and gibberish failures in voice before launch, while Agnost AI mines live conversations for frustration loops and repeated retries that synthetic tests miss. The framework matters because agencies bill for reliability, not for eval coverage. A retainer client tolerates a slow dashboard refresh but not an agent that leaks a competitor's pricing into a chat reply. Mapping the surface first tells you which 20% of failure modes justify continuous monitoring and which can wait for a quarterly review. The output is a one-page risk register per client deployment, priced into the retainer as production assurance.
Decision and risk
How to judge the fit, and the ways it goes wrong.
- AI Evaluation Rule: Instrument Before You Automate Client-Facing AgentsEvaluation Rule
Wire tracing, scoring, and a human review checkpoint into any agent that touches client-facing output before it goes live, not after the first incident.
- When Agent Autonomy Reaches Client-Facing Systems, Gate It With Trace-Level EvalsEvaluation Rule
Treat trace-level evaluation as a launch gate for any agent that touches client-facing systems, not as a post-launch upgrade.
- Evaluation Pipeline Before Launch vs Retrofit After Client EscalationDecision Framework
IF an agency is shipping LLM features into a client retainer and has no trace-level record of what the model did on a given day, THEN instrument evaluation and observability before the next release, because the first production failure will otherwise be diagnosed from screenshots and client memory. IF the agency already captures spans, scores, and cost per session, THEN the decision shifts to whether to productize that telemetry as a paid reliability line item rather than absorb it as overhead.
- The Demo-Only Trap: Why AI Evaluation & Observability Stalls After the PilotFailure Pattern
- The Judge-Only Trap: Why AI Evaluation & Observability Fails When Scoring Is AutomatedFailure Pattern
Delivery system
Blueprints and procedures for running it as a service.
- Production-Ready AI Evaluation Pipeline Build (10-15 days)Implementation Blueprint
A fixed-scope engagement that instruments a client's LLM or agent deployment with tracing, scoring, and drift detection so the agency can hand over a system that is monitored, not merely shipped. It converts an unverifiable AI pilot into a retainer-backed production asset.
- Production Trace Review Cadence (Retention)Operating Procedure
- Pre-Launch Agent Failure Simulation (QA)Operating Procedure
- Evaluation Baseline Freeze Before Client Launch (Handoff)Operating Procedure
13 modules selected for Leibler
Frequently Asked Questions
Answers about pricing, setup
Kullback reads execution traces from your AI agents and reconstructs the tools, data, and rules they used during real runs. It then replays those traces to verify the rebuild is accurate, generates per-task verifiers that check final data for pass/fail status, and produces reports showing which runs succeeded. Your team validates agent behavior without manual transcript review.
Kullback is open-source and free to use. There is no per-seat pricing or subscription fee. Your team hosts and runs it on your own infrastructure.
AI development leads and engineers use Kullback to debug agent failures and validate task execution. Project Managers and QA leads use it to generate pass/fail reports and track agent reliability across deployments. Founders and Operations leads use it to verify that deployed agents behave consistently before client handoff. Best suited for agencies building custom AI agents as a core service.
For an AI development team running 5+ agent deployments per month, Kullback saves approximately 4-6 hours per week by eliminating manual trace review and transcript-based debugging. Actual savings depend on the number of agent runs per week and the complexity of your verification logic. Teams with fewer deployments see lower absolute time savings but higher per-project ROI.
Kullback is framework-agnostic and works with any agent system that produces execution traces. Your team must integrate trace collection into your agent codebase, then point Kullback at those traces. Setup time is typically 2-4 weeks for a team new to trace-based testing.
No. Kullback requires access to detailed execution traces from agents you control. It cannot reconstruct behavior from third-party SaaS agent platforms or black-box LLM APIs that do not expose their internal logs.