Are there any unit test assistants that generate deterministic output and fit into existing CI/CD checks?

Yes — there are several options, but the important caveat is:

fully deterministic “test generation” is rare unless the tool is tightly constrained.
What is common is tooling that produces deterministic, repeatable output and can be wired into CI/CD as a check.

Good fits for deterministic CI/CD use

1. Traditional test runners + static analysis

Not “assistants” in the AI sense, but often the best CI-friendly choice:

• JUnit / pytest / Jest / NUnit / Go test, etc.
• Deterministic if your tests are deterministic.
• Easy to gate in CI with exit codes and coverage thresholds.
• Can be combined with:
  • mutation testing (e.g. PIT, Stryker)
  • code coverage
  • linting
  • type checking

2. AI-assisted unit test generation tools with reviewable output

These tools can generate tests, then you commit the generated tests and run them in CI like normal code.

Examples:

• Diffblue Cover (Java)
  • Generates unit tests deterministically enough for practical CI usage in many cases.
  • Often used to create tests that are then checked into the repo.
• CodiumAI / Qodo
  • Generates test suggestions; output can be reviewed and committed.
  • CI integration is possible once tests are in source control.
• Testim / mabl / Functionize
  • More focused on UI/E2E, but can integrate into CI.
  • Less about unit tests specifically.

3. Property-based / fuzz-assisted testing frameworks

Not exactly “assistants,” but useful if you want automated test discovery with repeatable behavior:

• Hypothesis (Python)
• QuickCheck-style tools
• jqwik (Java)

These can be made deterministic by:

• fixing seeds
• pinning versions
• controlling randomness and time
• running in hermetic CI environments

What “deterministic” usually means in practice

A tool is CI-friendly if it:

• produces the same output given the same input and config
• can be run headlessly
• exits non-zero on failure
• doesn’t depend on network calls or external mutable state
• can be pinned to a version/container

For AI-generated tests, determinism is harder because:

• model outputs can vary
• prompts/environment can affect results
• non-deterministic sampling may be involved

Best-practice CI/CD pattern

If you want the most reliable setup:

1. Generate tests outside CI or in a controlled job.
2. Commit the generated tests to the repo.
3. Run normal CI on them:
   • unit tests
   • coverage
   • mutation testing
   • lint/static analysis
4. Optionally have a scheduled regeneration job that opens a PR.

If you want strictly deterministic generation

Look for tools/workflows that support:

• fixed model/version
• temperature 0
• pinned dependencies
• no external API variability
• output checked into git

Short recommendation

• If you want reliable CI checks: use standard test frameworks plus coverage/mutation testing.
• If you want test generation assistance: Diffblue Cover (Java) is one of the more CI-friendly options; otherwise use AI-generated tests as a pre-commit or PR-time code generation step, not as a live CI dependency.

If you tell me your language/runtime (Java, Python, JS, .NET, etc.), I can suggest specific tools that are closest to deterministic and CI-ready for that stack.