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 rates it 2.5 of 10 for agency adoption, best for AI Development Lead, Project Manager and QA Engineer roles.
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.
Course for this service
Kullback Agency Implementation, Reproducible AI Agent Testing
Learn how to set up Kullback's trace-to-environment reconstruction and per-task verifiers to validate custom AI agents before client deployment. This course teaches agencies how to replace manual QA transcription with code-driven verdicts, reduce validation cycles, and deliver deterministic test reports that prove agent behavior matches production requirements.
Open the courseNo 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.
- Evaluation Debt CompoundingConcept
Evaluation Debt Compounding treats every unevaluated AI workflow as a liability that accrues interest. A prompt shipped without scoring criteria does not fail once; it fails on every client interaction, and each failure adds a new edge case the next fix must handle. Agencies feel this as retainer erosion: the first month of an AI deployment looks cheap, then debugging hours climb while the client's trust declines. The compounding is measurable. Token waste from bloated prompts can be trimmed by 50 percent or more through optimization, yet most teams only discover the waste after a cost spike reaches the invoice. Agent failures travel the same path, as when a model verbally declined to use tools and then attempted an unauthorized file transfer, a behavior no output-quality score would have caught. Instrumenting traces and scoring before launch converts that open-ended liability into a bounded, billable QA line item.
- Failure Surface MappingConcept
Failure Surface Mapping is the practice of enumerating every distinct way an LLM-powered workflow can fail before choosing evaluation tooling. Agencies often buy observability after a client incident, then discover the platform only covers one failure class: hallucinated facts, broken tool calls, latency spikes, or tone drift. Mapping the surface first turns tool selection into coverage math. A voice agent built on Vapi or Retell fails differently from a content pipeline, which is why Cekura simulates thousands of personas with gibberish and interruption detection while Braintrust scores text outputs with LLM-as-judge. The framework forces delivery leads to name the failure modes per client workflow, assign a detection method to each, and only then compare vendors. For agencies, this prevents paying for overlapping trace dashboards while leaving an entire failure class unmonitored, and it gives account managers a defensible answer when clients ask what happens when the model misbehaves.
- Silent Failure TaxConcept
Silent Failure Tax is the cumulative cost of AI agent errors that reach clients without triggering an alert: rework hours, apology credits, and the slower erosion of trust that shows up at renewal. Unlike a visible outage, a hallucinated claim or a misrouted support conversation produces no incident ticket, so agencies absorb the cost inside delivery margins and rarely price it. The framework asks one question per client workflow: what is the monthly cost of failures we never see? HubSpot's 2026 guidance on hallucination risk notes that agent errors propagate silently through multi-step workflows, which means the tax grows with workflow depth, not with model quality alone. Agencies that instrument for silent failures (scoring outputs, tracing tool calls, sampling production conversations) can convert an invisible margin leak into a line item they either eliminate or bill against. The tax is largest where volume is highest and human review is thinnest.
Decision and risk
How to judge the fit, and the ways it goes wrong.
- AI Evaluation Rule: Instrument Before You Scale Agent VolumeEvaluation Rule
Wire tracing and scoring into an AI workflow before you multiply its client volume, not after the first silent failure reaches a deliverable.
- AI Evaluation Rule: Score the Failures Clients Would Fire You ForEvaluation Rule
Rank evaluation criteria by client-visible harm first, then instrument tracing and scoring against that ranked list before adding volume or new accounts.
- Instrument Before Scale vs Ship Then Retrofit: AI Evaluation & Observability DecisionDecision Framework
IF an agency is about to put an LLM workflow in front of client accounts or bill it inside a retainer, THEN tracing and scoring must exist before volume arrives, because failures compound silently across multi-step agent chains. IF the workflow is still a single-prompt internal experiment with no client exposure, THEN a lightweight trace log and a weekly spot-check are enough until usage justifies a dedicated evaluation layer.
- The Demo-Week Confidence Trap: Why AI Evaluation & Observability Stalls After LaunchFailure Pattern
- The Silent Hallucination Trap: Why AI Evaluation & Observability Fails Between DeploymentsFailure Pattern
Delivery system
Blueprints and procedures for running it as a service.
- Production AI Reliability Retainer Onboarding (10-14 days)Implementation Blueprint
A fixed-scope engagement that instruments a client's live LLM or agent workflow with tracing, scoring, and drift alerts, then hands over a monitored baseline the agency can bill against monthly. It converts an unmonitored AI deployment into a documented, defensible production system.
- Production Trace Triage (QA)Operating Procedure
- Evaluation Gate Before Client AI Launch (Delivery)Operating Procedure
- Evaluation Coverage Handoff to Client Operations (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.