Prove your AI agents work before you ship them.
Know where your AI agents break before your users do.
Truvyx is the evaluation and diagnostic intelligence platform for multi-agent AI systems. It tests agents against operational constraints your team defines, with mathematical proof where proof is possible, and investigates production behavior conversationally when something goes wrong.
No credit card required. Free tier includes 50 evaluation runs per month.
The problem
When multi-agent AI systems fail, most teams don't find out why.
Multi-agent AI systems don't produce one output from one model. They're networks of specialized agents, each handling part of a decision and passing information to the next. When the result is wrong (a scheduling conflict, a misapplied regulation, a missed escalation), the failure could have originated in any agent, at any step.
Standard AI monitoring tools tell you a request failed, how long it took, and what it cost. They watch the infrastructure around your AI system. They don't tell you whether the reasoning inside it was correct, and when it wasn't, they can't tell you why.
Truvyx does both. It tells you before deployment whether your system reasons correctly against the rules that actually govern your environment, and after deployment, it tells you exactly which agent went wrong, why, and what the smallest fix would have been.
fault types classified automatically
SMT-verified, unbypassable guardrails
signed, verifiable audit records
The platform
Six modules. One evaluation and diagnostic pipeline.
Scenario Studio
Build test scenarios from your real operational constraints, not generic benchmarks. An expert can produce a full evaluation scenario in minutes instead of hours.
Constraint Engine
Define the rules that govern your environment as formal constraints. Truvyx checks whether your scenarios are solvable, flags contradictory rules, and generates the correct reference answer your AI system should produce.
Verifier Factory
Automatically generates scoring scripts that check feasibility, completeness, and optimality against your constraint set, and runs them on every deployment, automatically.
Decomposition Designer
Design and document how work should be divided across your agents, then compare what your system actually did against what it should have done.
Benchmark Registry
A version-controlled library of test scenarios, public and private, with leaderboards comparing how different AI systems perform against the same constraints.
Agentic RCA Engine
When an agent fails, Truvyx traces the failure to its root cause, classifies it against a 9-type fault taxonomy, and generates the smallest change that would have produced the correct result.
Inside the platform
Four engines, one continuous loop of evidence.
Turn a sentence into a machine-checkable scenario.
Describe the job in plain language. Scenario Studio expands it into typed agents, roles, dependencies, and success criteria you can version, fork, and replay.
- Natural-language authoring with structured output
- Versioned scenarios, diffed run-over-run
- Reusable across teams and benchmarks
|Catch impossible tasks before an agent ever runs.
The Constraint Engine encodes temporal, resource, and regulatory rules, then a solver proves feasibility up front. No more burning a run on a task that was never satisfiable.
- Temporal, resource, and regulatory constraints
- Solver-backed feasibility proof
- Hard and soft constraint tiers
|Know exactly why a run failed, not just that it did.
When a run breaks, the RCA Engine traces the causal chain to a single root fault and classifies it into one of nine fault types. Replay counterfactuals to confirm the fix.
- Nine fault types classified automatically
- Causal-chain tracing to the root node
- Counterfactual replay for every run
|Guard production with continuous regression monitoring.
Wire monitoring into every deploy. Truvyx watches overall scores and emerging fault types, then alerts Slack, email, or PagerDuty the moment a regression appears.
- Score and fault-type regression detection
- Slack, SMTP, and PagerDuty notifications
- Signed, verifiable audit records (RS256)
|Full lifecycle
Truvyx doesn't stop working once your agents ship.
Define your operational constraints, generate a private benchmark suite, and run your AI system against it. Formal verification proves, mathematically and not probabilistically, that a defined guardrail cannot be bypassed by any agent input. This is the rigor a regulated deployment needs before it goes live.
Ask Truvyx directly, in Slack, in your IDE via MCP, or in the dashboard, why an agent did what it did. Every answer cites the specific record behind it: the run, the constraint, the fault classification. Truvyx also watches continuously for silent model drift behind hosted AI providers, and tracks the specific patterns where your agents and your human reviewers disagree.
One platform, one fault taxonomy, one audit trail: from the first test run through every day your agents are live in production.
Everywhere you work
Truvyx isn't another tab you have to open.
Truvyx runs as a standard MCP server. If your coding agent or IDE speaks MCP, it can call Truvyx directly: search traces at a behavioral level, investigate why an agent did what it did, or trigger a verifier or contract test, without leaving your editor.
Works today with
Claude Code, Cursor, Windsurf, Cline, Continue.dev, Zed, Goose, and VS Code's native agent mode.
Works with any MCP client. MCP is an open protocol, not a Truvyx-specific integration; Truvyx doesn't maintain a list of “supported” tools so much as a commitment to the standard itself. If a new coding agent speaks MCP, Truvyx already works with it.
Why Truvyx
Proof, not just probability.
Most AI evaluation tools score outputs using another AI model as a judge: an LLM scoring an LLM. That approach is useful, and Truvyx uses it too, for the judgment calls that genuinely require it. But it has a ceiling: it's probabilistic. It will eventually be wrong, and there's no way to prove otherwise.
For the rules that matter most (a regulatory threshold, a safety constraint, a hard operational limit), Truvyx goes further. Using a formal SMT solver, Truvyx mathematically proves that no possible agent input can bypass a defined guardrail. Not “we tested common cases and didn't find a failure.” Proven.
Every finding Truvyx produces is labeled by exactly how certain it is: mathematically verified, rule-based, or AI-assessed. Nothing is ever presented with more confidence than it has actually earned.
| LLM-as-judge platforms | Truvyx | |
|---|---|---|
| Correctness basis | Probabilistic scoring | Mathematical proof where possible, disclosed judgment where not |
| Multi-agent fault detection | Single-agent trajectory analysis | 9-type fault taxonomy across agent-to-agent coordination |
| Guardrail guarantee | “Tested and passed” | “Proven unbypassable” (Z3-verified) |
| Compliance output | Evaluation report | Cryptographically signed, examiner-ready audit record |
| Production investigation | Dashboard-based | Dashboard, plus conversational in Slack or your IDE (every answer cited) |
How it works
Three steps to evidence you can trust.
Define the scenario
Describe the task in plain language. Truvyx turns it into a machine-checkable spec with agents, roles, and constraints.
Run your agents
Submit any agent system through the SDK or UI. A sandboxed verifier scores feasibility, completeness, and optimality.
Diagnose and prove
Read the root-cause report, replay counterfactuals, and export a signed audit record for compliance.
Built for engineers
Wire evaluation into your pipeline in minutes.
Submit a run from CI, poll for the verdict, and gate your deploy on the score. The SDK speaks plain Python and returns structured results you can act on.
Built for regulated industries
Where “probably correct” isn't good enough.
Truvyx is built for teams deploying multi-agent AI in operationally complex or regulated environments.
Healthcare
Clinical scheduling, resource allocation, patient safety constraints
Financial Services
Credit underwriting, fraud detection, regulatory compliance
Government
Audit selection, benefits eligibility, legally defensible decisions
Insurance
Claims settlement, underwriting risk, regulatory solvency
Logistics
Multi-hub routing, capacity planning, cross-border compliance
IT Operations
Incident response, capacity planning, SLA-bound decisions
Project Management
Multi-project scheduling, resource conflict resolution
Your custom organisation
Don't see your industry? The Constraint Engine encodes any rule set. Bring your own operational or regulatory constraints and we'll help you model them.
Every evaluation run in Compliance Mode produces a cryptographically signed, tamper-evident audit record (automatically, with no additional documentation effort required).
Frequently asked questions
Straight answers, no pronouns to trace back.
How is Truvyx different from LLM-as-judge evaluation tools?
LLM-as-judge tools score AI outputs using another AI model, which is inherently probabilistic. Truvyx uses that approach only where genuine judgment is required, and additionally offers formal mathematical verification via an SMT solver for guardrails that need to be provably unbypassable, not just probably correct.
Does Truvyx only work before deployment?
No. Truvyx evaluates agents before deployment through constraint-based testing and formal verification, and continues working after deployment through root cause analysis, continuous production drift monitoring, and conversational investigation of live agent behavior.
What is the Truvyx fault taxonomy?
Truvyx classifies multi-agent AI failures into 9 types: Decomposition Fault, Constraint Blindness, Coordination Breakdown, Optimization Failure, Hallucinated Dependency, Information Boundary Violation, Temporal Misalignment, Contract Violation, and Disparate Impact.
What does “formally verified” actually mean?
It means Truvyx used a mathematical solver (Z3) to prove that no possible input, across the entire space of values an agent could produce, can violate a specific defined rule. This is a categorically stronger guarantee than a test suite passing.
Your agents will make mistakes. Find out before it costs you.
Start free, bring your own agents, and get a root-cause report on your first failing run.
No credit card required.