Agent CrashLab

Why I started this

AI agents are usually demonstrated on the happy path. Production failures are messier: a tool times out, retrieved text contains a prompt injection, memory becomes inconsistent, or one agent in a workflow returns a confident lie. Teams need a repeatable way to discover those failures before users do.

What Agent CrashLab does

Agent CrashLab turns an agent's tools, policies, and expected behavior into executable safety tests. A developer connects an agent repository or workflow, chooses the rules that must never be broken, and launches a test run.

CrashLab then:

• maps the agent's tools, permissions, prompts, and memory boundaries;
• generates adversarial scenarios from the selected policies;
• runs those scenarios in isolated Token Factory Sandboxes;
• records tool calls, policy violations, latency, cost, and pass or fail evidence;
• groups failures in a heatmap instead of hiding them inside chat logs;
• proposes a focused repair; and
• reruns the exact failed scenario so the developer can see whether the repair worked.

The first demo scenario is a refund-support agent. Its core rule is simple: never issue a refund above a configured limit without human approval. CrashLab tests that rule against malicious retrieved text, incomplete customer records, tool failures, stale memory, and conflicting instructions.

How it is designed

NVIDIA Nemotron handles the work that benefits from reasoning: reading the workflow, designing adversarial cases, and diagnosing a failed run. Deterministic assertions decide whether a policy passed. The model does not grade its own answer.

Nebius Token Factory provides model access and isolated execution. Independent scenarios can run in parallel, which makes a failure matrix practical instead of turning it into a long serial test. A smaller Nemotron variant can simulate users and tools for routine calls, while a larger reasoning model handles test planning and diagnosis.

Each run produces a compact evidence bundle: the initial policy, scenario inputs, tool trace, assertion result, proposed change, and verification result. A developer should be able to reproduce a failure without trusting a summary.

What I am building first

The MVP deliberately stays narrow. It supports one reference agent, four failure families, deterministic policy assertions, a parallel run view, and one repair-and-rerun path. Repository-wide autonomous changes, arbitrary agent frameworks, and automatic production deployment are later work.

The key demo moment is not a generated report. It is watching a plausible agent violate a policy, seeing the exact trace that caused it, applying a small repair, and rerunning the same case successfully.

Main challenges

The hardest design problem is separating creative test generation from trustworthy evaluation. Another is making failures reproducible when model responses vary. CrashLab addresses both by storing scenario seeds and traces, using explicit assertions, and keeping a human approval step before code changes.

This project is being developed for the Nebius x NVIDIA Global AI Hackathon. Performance figures, model comparisons, and infrastructure measurements will be added only after they are observed in repeatable runs.

Built With

• docker
• fastapi
• nebius-token-factory
• next-js
• nvidia-nemotron
• postgresql
• python
• tavily
• typescript