Overview

Run repeatable AI red teaming and functional evaluations against models, agents, and LLM endpoints with TrustTest.

TrustTest is a testing framework for AI red teaming and functional evaluation. It helps security and engineering teams find unsafe behavior, test model responses against defined criteria, and record results across repeated runs.

AI red teaming with TrustTest

Traditional test frameworks verify application logic and performance. TrustTest adds the components needed for adversarial testing: targets, generated or curated test cases, attack techniques, evaluators, and structured results.

You can point the same workflow at a model, agent, or HTTP endpoint. This keeps the assessment process consistent when you change providers or move a workload between environments.

Run an assessment

The following example runs an assessment against an HTTP endpoint and sends the results to NeuralTrust:

import os
from typing import List

from dotenv import load_dotenv

import trusttest
from trusttest.catalog.red_team import run_red_teaming
from trusttest.language_detection.types import LanguageType
from trusttest.targets.http import HttpTarget, PayloadConfig

load_dotenv(override=True)


target = HttpTarget(
    url="https://your-api.com/chat",
    headers={"Content-Type": "application/json"},
    payload_config=PayloadConfig(format={"message": "{{ test }}"}),
    concatenate_field="response",
)

client = trusttest.client(
    type="neuraltrust",
    token=os.getenv("TARGET_TOKEN"),
    target_id=os.getenv("TARGET_ID"),
)

languages: List[LanguageType] = ["English"]
for language in languages:
    run_red_teaming(target, language=language, client=client)

Coverage and workflow

• Test first-party models and third-party APIs through a consistent target interface.
• Generate test cases automatically or supply your own datasets and prompts.
• Use built-in probes and algorithmic attacks to exercise security and safety controls.
• Evaluate responses across scenarios, edge cases, languages, and model behaviors.
• Track test cases, evaluations, scenarios, and results locally or in NeuralTrust.
• Combine AI red teaming with functional evaluations in the same workflow.

Why use TrustTest?

TrustTest makes the process repeatable. Instead of treating each assessment as a separate exercise, teams can keep the target, test generation, evaluation criteria, and results together.

This approach helps teams:

1. Identify security and safety weaknesses before a model or agent reaches production.
2. Rerun assessments after model, prompt, retrieval, or application changes.
3. Select probes and evaluators that match the risks of a specific workload.
4. Compare results across models, versions, languages, and environments.
5. Retain evidence for investigation, reporting, and remediation.

Frequently asked questions

When should I rerun an assessment?

Run another assessment after material changes to the model, system prompt, tools, retrieval data, or surrounding application. Run assessments regularly to detect regressions as the system evolves.

Can results stay in my environment?

Yes. Use FileSystemClient to store scenarios, test sets, and results as JSON under a local path. Use NeuralTrustClient when you want to persist those artifacts in the NeuralTrust platform. See Connect to NeuralTrust for both options.

What systems can TrustTest evaluate?

The Python library supports HttpTarget for REST APIs and custom target implementations for other model interfaces. The web UI currently requires an LLM exposed through a REST API. Multi-turn probes require a ConversationTarget; HttpTarget already provides that interface.

Does adversarial testing replace functional evaluation?

No. AI red teaming looks for security and safety failure modes, while functional evaluation checks whether the system meets expected requirements. TrustTest supports both, so teams can assess each area separately or as part of the same test plan.