Rogue — AI Agent Evaluator & Red Team Platform

Stress-test your AI agents before attackers do, with automated evaluation and red teaming.

Stars
★ 1.1k
Last updated
5mo ago
License
NOASSERTION
Primary language
Python

At a glance

How it runs
CLISelf-hosted service
Works with
Universal · cross-platformOpenAI API · Claude API
Cost
Free software; you pay for model usage
Setup effort
Low · running in minutes
You'll need
Python 3.10+uvxShell / CLINetwork accessLocal filesystem
Typical use
DevOps engineer integrates Rogue CLI into CI/CD pipeline for regression testing of agent policies.
Not a fit if
  • Teams wanting free commercial hosting of the platform

What does this agent do, and when should you use it?

Rogue is a platform for evaluating and red-teaming AI agents, featuring two modes: automatic evaluation and red teaming. Automatic evaluation verifies agent behavior against business policies, while red teaming simulates adversarial attacks (75+ vulnerabilities, 12 security categories, 20+ attack techniques). It operates on a client-server architecture with a TUI (Go + Bubble Tea) and CLI, supporting protocols A2A, MCP, and direct Python function calls. Users can launch via uvx and configure a judge LLM to evaluate agent interactions. Risk scoring is CVSS-based, and scans are reproducible with random seeds. The license is proprietary; free for personal and internal use, commercial hosting requires a license.

Rogue reads business context and scenario files, connects to the target agent via CLI/TUI (e.g., --evaluated-agent-url), and uses a judge LLM (e.g., openai/gpt-4o-mini) to evaluate conversations. In red team mode, it executes attacks across categories (encoding, social engineering, injection, semantic, technical), logs vulnerabilities, and computes CVSS risk scores (0-10). Supports --random-seed for reproducibility. It generates reports in Markdown, CSV, and JSON. Example CLI invocation: 'uvx rogue-ai cli --protocol python --python-entrypoint-file ./my_agent.py --judge-llm openai/gpt-4o-mini'. TUI provides real-time monitoring.

  1. DevOps engineer integrates Rogue CLI into CI/CD pipeline for regression testing of agent policies.
  2. Security auditor performs red teaming against AI systems using OWASP and MITRE frameworks.
  3. Developer quickly tests a custom Python agent using --protocol python without setting up a server.
  4. Product team validates that new agent versions comply with business policies before release.
  5. Compliance team generates vulnerability reports aligned with GDPR and EU AI Act.

How do you install or deploy this agent?

Requires Python 3.10+ and uvx (install from Astral). Run 'uvx rogue-ai' for TUI or 'uvx rogue-ai cli' for CLI; uvx handles installation. Configure LLM API keys (OPENAI_API_KEY, ANTHROPIC_API_KEY, or GOOGLE_API_KEY) as environment variables.

How do you use this agent?

  1. Start the target agent (e.g., sample t-shirt store: 'uvx rogue-ai --example=tshirt_store'). 2. In TUI, set Agent URL (e.g., http://localhost:10001) and mode (Automatic Evaluation or Red Teaming). 3. For CLI: run 'uvx rogue-ai cli --evaluated-agent-url http://localhost:10001 --judge-llm openai/gpt-4o-mini --business-context-file ./.rogue/business_context.md'. 4. Review generated reports (default output in current directory).

What are this agent's strengths and limitations?

Pros
  • Dual functionality: automatic evaluation and red teaming in one tool.
  • Supports multiple protocols (A2A, MCP, Python), easing integration with different agent types.
  • CVSS-based risk scoring and reproducible scans with random seeds.
  • TUI provides real-time conversation monitoring and multiple report export formats.
Limitations
  • Proprietary license; commercial hosting requires payment, personal/internal use is free but limited.
  • Requires external LLM API keys (OpenAI/Anthropic/Google), incurring API costs.
  • No support for local models; relies on platform APIs.
  • Full red team scan can be time-consuming (30-45 minutes).

How does this agent compare with similar options?

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
Rogue — AI Agent Evaluator & Red Team Platform This agent 43 · Major gaps CLIFree + model costs ★ 1.1k 5mo ago Python OpenAI API · Claude API
Agent Learning Kit 38 · Major gaps CLIFree + model costs ★ 128 3d ago Python —
RAMPART 51 · Major gaps Library / SDKFree + model costs ★ 421 4d ago Python —
NVIDIA NeMo Agent Toolkit 65 · Some gaps CLIFree + model costs ★ 2.7k today Python —

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Major gaps
43/ 100 5-point scale 2.2 / 5
Trust 7/29
Reliability 6/14
Adaptability 12/18
Convention 8/18
Effectiveness 7/13
Verifiability 3/8
Why each dimension lost points
Trust7 / 29 · 1.2/5

Evidence shows: CLI supports auth types (API_KEY, BEARER_TOKEN, BASIC_AUTH) but least privilege not explicit; user confirmation missing (no interactive confirmation step); data flow transparency partially present (README describes architecture and protocols but not detailed data flow); sensitive data handling uses SecretStr and credential validation but storage/transmission security not specified; dependency security has version pins and CI build but no vulnerability scanning mentioned; external effects include network requests and file outputs but side effects not clarified; rollback not mentioned; source attribution has copyright and license but publisher unverified. Deductions: missing user confirmation, rollback, insufficient data flow and sensitive data details.

Reliability6 / 14 · 2.1/5

Evidence shows: README and pyproject.toml consistent, test files exist but no test results; dependencies partially pinned but availability not assured; failure messages not documented. Deductions: dependency availability and failure messages lack evidence.

Adaptability12 / 18 · 3.3/5

Evidence shows: README identifies target users (developers and security teams) and scenarios (automatic evaluation and red teaming); capability boundaries via scan types and protocols; trigger precision via CLI options and config; environment fit supports multiple protocols and Python versions. Deductions: limitations and boundary conditions not explicit.

Convention8 / 18 · 2.2/5

Evidence shows: README well-structured with quick start and docs links; install notes via uvx; naming stable (rogue-ai); examples and FAQ links present; known limitations not explicit; license is MIT with Commons Clause but metadata NOASSERTION; versioning and changelog absent; maintenance responsibility via security policy but not explicit. Deductions: license metadata inconsistency, missing versioning and changelog.

Effectiveness7 / 13 · 2.7/5

Evidence shows: output reports support Markdown, CSV, JSON, high usability; marginal value in providing automated evaluation and red teaming; cost-benefit not explicit but many dependencies. Deductions: cost-benefit lacks evidence.

Verifiability3 / 8 · 1.9/5

Evidence shows: README claims features but no test results or independent verification; cross-source corroboration limited; facts and inferences not clearly separated. Deductions: claims lack traceability.

Risks and how to mitigate them
  • Not found in source: confirmation before actingTurn on (or add) a confirmation step before it acts, and try it in a sandbox or test environment before real data.
  • Not found in source: rollback or recovery pathBack up first, or work on a git branch or snapshot, so its changes can be undone.
  • License metadata is NOASSERTION but LICENSE.md is MIT with Commons Clause; verify actual license.
  • Publisher unverified, identity unknown; evaluate cautiously.
  • Many dependencies with some pinned versions; check supply chain security.
  • No user confirmation mechanism; may execute external actions automatically.
  • No rollback mechanism; operations may be irreversible.
Evidence confidence: Low Reviewed Aug 09, 2026 Reviewed revision e1c5b5631870
See the full review method →

Recent releases

Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.

  1. v0.6.4
    Release notes excerpt
    What's Changed * hotfix/cli with server support python protocol by @yuval-qf in https://github.com/qualifire-dev/rogue/pull/172 Full Changelog: https://github.com/qualifire-dev/rogue/compare/v0.6.3...v0.6.4
    View on GitHub ↗
  2. v0.6.3
    Release notes excerpt
    Full Changelog: https://github.com/qualifire-dev/rogue/compare/v0.6.2...v0.6.3
    View on GitHub ↗
  3. v0.6.2 Release v0.6.2
    Release notes excerpt
    What's Changed * feat(multi-turn): runbook-aware per-turn attach_kwargs (v0.6.2) by @drorIvry in https://github.com/qualifire-dev/rogue/pull/170 Full Changelog: https://github.com/qualifire-dev/rogue/compare/v0.6.1...v0.6.2
    View on GitHub ↗

FAQ

How to choose a red team scan type?
Basic scan takes ~2-3 minutes and covers 5 curated vulnerabilities; Full scan covers 75+ vulnerabilities in ~30-45 minutes; Custom allows selecting vulnerabilities and attacks.
Does it support local LLMs?
The README only mentions OpenAI, Anthropic, and Google APIs; local models are not mentioned.
Can it be integrated into CI/CD?
Yes, the CLI mode is designed for non-interactive environments and can be added to pipelines.
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents