We spent the past year building DeepEval with the goal of providing the best LLM evaluation developer experience, growing it to run over 600K evaluations daily in CI/CD pipelines of enterprises like BCG, AstraZeneca, AXA, and Capgemini. But the fact that DeepEval simply runs, and does nothing with the data afterward, isn\u2019t the best experience. If you want to inspect failing test cases, identify regressions, or even pick the best model/prompt combination, you need more than just DeepEval. That\u2019s why we built a platform around it.
Here\u2019s a quick demo video of how everything works: https://youtu.be/PB3ngq7x4ko
Confident AI is great for RAG pipelines, agents, and chatbots. Typical use cases involve allowing companies to switch the underlying LLM, rewrite prompts for newer (and possibly cheaper) models, and keep test sets in sync with the codebase where DeepEval tests are run.
Our platform features a "dataset editor," a "regression catcher," and "iteration insights". The datasets editor in Confident AI allows domain experts to edit datasets while keeping them in sync with your codebase for evaluation. We\u2019ll then generate sharable LLM testing/benchmark reports once DeepEval has finished running evaluations on these datasets that are pulled from the cloud. The regression catcher then identifies any regressions in your new implementation, and we use these evaluation results to determine the best iteration based on your metric scores.
Our goal is to make benchmarking LLM applications so reliable that picking the best implementation is as simple as reading the metric values off the dashboard. To achieve this, the quality of curated datasets and the accuracy and reliability of metrics must be the highest possible.
This brings us to our current limitations. Right now, DeepEval\u2019s primary evaluation method is LLM-as-a-judge. We use techniques such as GEval and question-answer generation to improve reliability, but these methods can still be inconsistent. Even with high-quality datasets curated by domain experts, our evaluation metrics remain the biggest blocker to our goal.
To address this, we recently released a DAG (Directed Acyclic Graph) metric in DeepEval. It is a decision-tree-based, LLM-as-a-judge metric that provides deterministic results by breaking a test case into finer atomic units. Each edge represents a decision, each node represents an LLM evaluation step, and each leaf node returns a score. It works best in scenarios where success criteria are clearly defined, such as text summarization.
The DAG metric is still in its early stages, but our hope is that by moving towards better, code-driven, open-source metrics, Confident AI can deliver deterministic LLM benchmarks that anyone can blindly trust.
We hope you\u2019ll give Confident AI a try. Quickstart here: https://docs.confident-ai.com/confident-ai/confident-ai-intr...
The platform runs on a freemium tier, and we've dropped the need to signup with a work email for the next four days.
Looking forward to your thoughts!"},"title":{"matchLevel":"none","matchedWords":[],"value":"Launch HN: Confident AI (YC W25) \u2013 Open-source evaluation framework for LLM apps"}},"_tags":["story","author_jeffreyip","story_43116633","launch_hn"],"author":"jeffreyip","children":[43118409,43118881,43118969,43119072,43119323,43120211,43121129,43121178,43124903,43126359,43131559,43172556],"created_at":"2025-02-20T16:23:56Z","created_at_i":1740068636,"num_comments":27,"objectID":"43116633","points":117,"story_id":43116633,"story_text":"Hi HN - we're Jeffrey and Kritin, and we're building Confident AI (https://confident-ai.com). This is the cloud platform for DeepEval (https://github.com/confident-ai/deepeval), our open-source package that helps engineers evaluate and unit-test LLM applications. Think Pytest for LLMs.
We spent the past year building DeepEval with the goal of providing the best LLM evaluation developer experience, growing it to run over 600K evaluations daily in CI/CD pipelines of enterprises like BCG, AstraZeneca, AXA, and Capgemini. But the fact that DeepEval simply runs, and does nothing with the data afterward, isn\u2019t the best experience. If you want to inspect failing test cases, identify regressions, or even pick the best model/prompt combination, you need more than just DeepEval. That\u2019s why we built a platform around it.
Here\u2019s a quick demo video of how everything works: https://youtu.be/PB3ngq7x4ko
Confident AI is great for RAG pipelines, agents, and chatbots. Typical use cases involve allowing companies to switch the underlying LLM, rewrite prompts for newer (and possibly cheaper) models, and keep test sets in sync with the codebase where DeepEval tests are run.
Our platform features a "dataset editor," a "regression catcher," and "iteration insights". The datasets editor in Confident AI allows domain experts to edit datasets while keeping them in sync with your codebase for evaluation. We\u2019ll then generate sharable LLM testing/benchmark reports once DeepEval has finished running evaluations on these datasets that are pulled from the cloud. The regression catcher then identifies any regressions in your new implementation, and we use these evaluation results to determine the best iteration based on your metric scores.
Our goal is to make benchmarking LLM applications so reliable that picking the best implementation is as simple as reading the metric values off the dashboard. To achieve this, the quality of curated datasets and the accuracy and reliability of metrics must be the highest possible.
This brings us to our current limitations. Right now, DeepEval\u2019s primary evaluation method is LLM-as-a-judge. We use techniques such as GEval and question-answer generation to improve reliability, but these methods can still be inconsistent. Even with high-quality datasets curated by domain experts, our evaluation metrics remain the biggest blocker to our goal.
To address this, we recently released a DAG (Directed Acyclic Graph) metric in DeepEval. It is a decision-tree-based, LLM-as-a-judge metric that provides deterministic results by breaking a test case into finer atomic units. Each edge represents a decision, each node represents an LLM evaluation step, and each leaf node returns a score. It works best in scenarios where success criteria are clearly defined, such as text summarization.
The DAG metric is still in its early stages, but our hope is that by moving towards better, code-driven, open-source metrics, Confident AI can deliver deterministic LLM benchmarks that anyone can blindly trust.
We hope you\u2019ll give Confident AI a try. Quickstart here: https://docs.confident-ai.com/confident-ai/confident-ai-intr...
The platform runs on a freemium tier, and we've dropped the need to signup with a work email for the next four days.
Looking forward to your thoughts!","title":"Launch HN: Confident AI (YC W25) \u2013 Open-source evaluation framework for LLM apps","updated_at":"2026-06-14T02:35:39Z"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"sidmurali23"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["deepeval"],"value":"Hi HN, I\u2019m part of the Confident AI team and we\u2019re excited to share DeepTeam, an open-source framework that makes it trivial to penetration-test your LLM applications for 40+ security and safety risks. It has gained 400 on GitHub over the last month, and we\u2019d love your feedback!
Quick Introduction
- Detect vulnerabilities such as bias, misinformation, PII leakage, over-reliance on context, harmful content, and more\n- Simulate adversarial attacks with 10+ methods (jailbreaks, prompt injection, ROT13, automated evasion, data extraction, etc.)\n- Customize assessments to OWASP Top 10 for LLMs, NIST AI Risk Management, or your own security guidelines\n- Leverage DeepEval under the hood for robust metric evaluation, so you can run both regular and adversarial tests
Getting Started
# Install DeepTeam\n pip install -U deepteam\n\n # Clone the repo and run the example\n git clone https://github.com/confident-ai/deepteam.git\n cd deepteam\n python3 -m venv venv && source venv/bin/activate\n python examples/red_teaming_example.py\nWhy DeepTeam?
Most LLM safety tooling focuses on known benchmarks\u2014DeepTeam dynamically simulates attacks at runtime, so you catch novel, real-world threats and can track improvements over time via reusable attack suites.
We\u2019d love to hear:
- Which vulnerabilities you worry about most\n- How you integrate red-teaming into your CI/CD pipelines\n- Feature requests, contributions, and your toughest jailbreak stories
<https://github.com/confident-ai/deepteam>"},"title":{"matchLevel":"none","matchedWords":[],"value":"Show HN: DeepTeam \u2013 Open-Source Red-Teaming Framework for LLM Security"},"url":{"matchLevel":"none","matchedWords":[],"value":"https://github.com/confident-ai/deepteam"}},"_tags":["story","author_sidmurali23","story_44306963","show_hn"],"author":"sidmurali23","created_at":"2025-06-18T05:45:39Z","created_at_i":1750225539,"num_comments":0,"objectID":"44306963","points":4,"story_id":44306963,"story_text":"Hi HN, I\u2019m part of the Confident AI team and we\u2019re excited to share DeepTeam, an open-source framework that makes it trivial to penetration-test your LLM applications for 40+ security and safety risks. It has gained 400 on GitHub over the last month, and we\u2019d love your feedback!
Quick Introduction
- Detect vulnerabilities such as bias, misinformation, PII leakage, over-reliance on context, harmful content, and more\n- Simulate adversarial attacks with 10+ methods (jailbreaks, prompt injection, ROT13, automated evasion, data extraction, etc.)\n- Customize assessments to OWASP Top 10 for LLMs, NIST AI Risk Management, or your own security guidelines\n- Leverage DeepEval under the hood for robust metric evaluation, so you can run both regular and adversarial tests
Getting Started
# Install DeepTeam\n pip install -U deepteam\n\n # Clone the repo and run the example\n git clone https://github.com/confident-ai/deepteam.git\n cd deepteam\n python3 -m venv venv && source venv/bin/activate\n python examples/red_teaming_example.py\nWhy DeepTeam?
Most LLM safety tooling focuses on known benchmarks\u2014DeepTeam dynamically simulates attacks at runtime, so you catch novel, real-world threats and can track improvements over time via reusable attack suites.
We\u2019d love to hear:
- Which vulnerabilities you worry about most\n- How you integrate red-teaming into your CI/CD pipelines\n- Feature requests, contributions, and your toughest jailbreak stories
<https://github.com/confident-ai/deepteam>","title":"Show HN: DeepTeam \u2013 Open-Source Red-Teaming Framework for LLM Security","updated_at":"2025-06-18T08:03:41Z","url":"https://github.com/confident-ai/deepteam"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"nicolaib"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["deepeval"],"value":"Hi HN, I'm Nicolai. I'm working with a small team in Germany on Rhesis, an open-source platform for testing conversational LLM applications and agents. We\u2019re sharing an early community preview today.
Why we built this:\nWe saw teams repeatedly struggle with testing, e.g. scattered test cases, unclear or inconsistent metrics, and a lot of manual effort that still missed obvious failures before production. Most tools assume a single developer runs evals alone; in practice, testing tends to involve PMs, domain experts, QA, and engineers. We built Rhesis to make that collaboration straightforward.
What it does:\nRhesis is a self-hostable platform (with UI) where teams can create, run, and review tests for conversational AI systems.
A few core ideas:
- Test generation: Create and run tests for single-turns or full conversations; the platform can also assist with generating both single- and multi-turn scenarios using your domain context.
- Domain context / knowledge: Provide background material to guide test creation so you\u2019re not starting from an empty prompt.
- Collaboration tools: Non-technical teammates can write test cases, leave comments, and review results; developers can dig into failures with detailed traces and outputs.
- Unified metrics: Bring in eval metrics from DeepEval, RAGAS, and similar OSS frameworks without re-implementing them.
Current state:\nStill early. We shipped v0.4.2 last week with a zero-config Docker setup. Core flows work, but there are rough edges. Everything is MIT-licensed; an enterprise edition will come later, but the OSS core will remain free. We\u2019re currently focused on conversational applications because that\u2019s where we saw the biggest pain in evaluation and QA workflows.
Links:\nApp: app.rhesis.ai
GitHub: github.com/rhesis-ai/rhesis
Docs: docs.rhesis.ai
Happy to hear your thoughts and any answer questions about platform design, the architecture, or our thinking on collaborative testing workflows."},"title":{"matchLevel":"none","matchedWords":[],"value":"Show HN: Rhesis \u2013 Open-source platform for collaborative LLM application testing"},"url":{"matchLevel":"none","matchedWords":[],"value":"https://github.com/rhesis-ai/rhesis"}},"_tags":["story","author_nicolaib","story_45970388","show_hn"],"author":"nicolaib","children":[45977066],"created_at":"2025-11-18T18:54:21Z","created_at_i":1763492061,"num_comments":2,"objectID":"45970388","points":3,"story_id":45970388,"story_text":"Hi HN, I'm Nicolai. I'm working with a small team in Germany on Rhesis, an open-source platform for testing conversational LLM applications and agents. We\u2019re sharing an early community preview today.
Why we built this:\nWe saw teams repeatedly struggle with testing, e.g. scattered test cases, unclear or inconsistent metrics, and a lot of manual effort that still missed obvious failures before production. Most tools assume a single developer runs evals alone; in practice, testing tends to involve PMs, domain experts, QA, and engineers. We built Rhesis to make that collaboration straightforward.
What it does:\nRhesis is a self-hostable platform (with UI) where teams can create, run, and review tests for conversational AI systems.
A few core ideas:
- Test generation: Create and run tests for single-turns or full conversations; the platform can also assist with generating both single- and multi-turn scenarios using your domain context.
- Domain context / knowledge: Provide background material to guide test creation so you\u2019re not starting from an empty prompt.
- Collaboration tools: Non-technical teammates can write test cases, leave comments, and review results; developers can dig into failures with detailed traces and outputs.
- Unified metrics: Bring in eval metrics from DeepEval, RAGAS, and similar OSS frameworks without re-implementing them.
Current state:\nStill early. We shipped v0.4.2 last week with a zero-config Docker setup. Core flows work, but there are rough edges. Everything is MIT-licensed; an enterprise edition will come later, but the OSS core will remain free. We\u2019re currently focused on conversational applications because that\u2019s where we saw the biggest pain in evaluation and QA workflows.
Links:\nApp: app.rhesis.ai
GitHub: github.com/rhesis-ai/rhesis
Docs: docs.rhesis.ai
Happy to hear your thoughts and any answer questions about platform design, the architecture, or our thinking on collaborative testing workflows.","title":"Show HN: Rhesis \u2013 Open-source platform for collaborative LLM application testing","updated_at":"2026-03-05T23:02:21Z","url":"https://github.com/rhesis-ai/rhesis"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"jeffreyip"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["deepeval"],"value":"Hi HN, we\u2019re Jeffrey and Kritin, and we\u2019re building DeepTeam (https://trydeepteam.com), an open-source Python library to scan LLM apps for security vulnerabilities. You can start \u201cpenetration testing\u201d by defining a Python callback to your LLM app (e.g. `def model_callback(input: str)`), and DeepTeam will attempt to probe it with prompts designed to elicit unsafe or unintended behavior.
Note that the penetration testing process treats your LLM app as a black-box - which means that DeepTeam will not know whether PII leakage has occurred in a certain tool call or incorporated in the training data of your fine-tuned LLM, but rather just detect that it is present. Internally, we call this process \u201cend-to-end\u201d testing.
Before DeepTeam, we worked on DeepEval, an open-source framework to unit-test LLMs. Some of you might be thinking, well isn\u2019t this kind of similar to unit-testing?
Sort of, but not really. While LLM unit-testing focuses on 1) accurate eval metrics, 2) comprehensive eval datasets, penetration testing focuses on the haphazard simulation of attacks, and the orchestration of it. To users, this was a big and confusing paradigm shift, because it went from \u201cDid this pass?\u201d to \u201cHow can this break?\u201d.
So we thought to ourselves, why not just release a new package to orchestrate the simulation of adversarial attacks for this new set of users and teams working specifically on AI safety, and borrow DeepEval\u2019s evals and ecosystem in the process?
Quickstart here: https://www.trydeepteam.com/docs/getting-started#detect-your...
The first thing we did was offer as many attack methods as possible - simple encoding ones like ROT13, leetspeak, to prompt injections, roleplay, and jailbreaking. We then heard folks weren\u2019t happy because the attacks didn\u2019t persist across tests and hence they \u201clost\u201d their progress every time they tested, and so we added an option to `reuse_simulated_attacks`.
We abstracted everything away to make it as modular as possible - every vulnerability, attack, can be imported in Python as `Bias(type=[\u201crace\u201d])`, `LinearJailbreaking()`, etc. with methods such as `.enhance()` for teams to plug-and-play, build their own test suite, and even to add a few more rounds of attack enhancements to increase the likelihood of breaking your system.
Notably, there are a few limitations. Users might run into compliance errors when attempting to simulate attacks (especially for AzureOpenAI), and so we recommend setting `ignore_errors` to `True` in case that happens. You might also run into bottlenecks where DeepTeam does not cover your custom vulnerability type, and so we shipped a `CustomVulnerability` class as a \u201ccatch-all\u201d solution (still in beta).
You might be aware that some packages already exist that do a similar thing, often known as \u201cvulnerability scanning\u201d or \u201cred teaming\u201d. The difference is that DeepTeam is modular, lightweight, and code friendly. Take Nvidia Garak for example, although comprehensive, has so many CLI rules, environments to set up, it is definitely not the easiest to get started, let alone pick the library apart to build your own penetration testing pipeline. In DeepTeam, define a class, wrap it around your own implementations if necessary, and you\u2019re good to go.
We adopted a Apache 2.0 license (for now, and probably in the foreseeable future too), so if you want to get started, `pip install deepteam`, use any LLM for simulation, and you\u2019ll get a full penetration report within 1 minute (assuming you\u2019re running things asynchronously). GitHub: https://github.com/confident-ai/deepteam
Excited to share DeepTeam with everyone here \u2013 let us know what you think!"},"title":{"matchLevel":"none","matchedWords":[],"value":"Show HN: DeepTeam \u2013 Penetration Testing for LLMs"},"url":{"matchLevel":"none","matchedWords":[],"value":"https://github.com/confident-ai/deepteam"}},"_tags":["story","author_jeffreyip","story_44117323","show_hn"],"author":"jeffreyip","created_at":"2025-05-28T15:49:43Z","created_at_i":1748447383,"num_comments":0,"objectID":"44117323","points":3,"story_id":44117323,"story_text":"Hi HN, we\u2019re Jeffrey and Kritin, and we\u2019re building DeepTeam (https://trydeepteam.com), an open-source Python library to scan LLM apps for security vulnerabilities. You can start \u201cpenetration testing\u201d by defining a Python callback to your LLM app (e.g. `def model_callback(input: str)`), and DeepTeam will attempt to probe it with prompts designed to elicit unsafe or unintended behavior.
Note that the penetration testing process treats your LLM app as a black-box - which means that DeepTeam will not know whether PII leakage has occurred in a certain tool call or incorporated in the training data of your fine-tuned LLM, but rather just detect that it is present. Internally, we call this process \u201cend-to-end\u201d testing.
Before DeepTeam, we worked on DeepEval, an open-source framework to unit-test LLMs. Some of you might be thinking, well isn\u2019t this kind of similar to unit-testing?
Sort of, but not really. While LLM unit-testing focuses on 1) accurate eval metrics, 2) comprehensive eval datasets, penetration testing focuses on the haphazard simulation of attacks, and the orchestration of it. To users, this was a big and confusing paradigm shift, because it went from \u201cDid this pass?\u201d to \u201cHow can this break?\u201d.
So we thought to ourselves, why not just release a new package to orchestrate the simulation of adversarial attacks for this new set of users and teams working specifically on AI safety, and borrow DeepEval\u2019s evals and ecosystem in the process?
Quickstart here: https://www.trydeepteam.com/docs/getting-started#detect-your...
The first thing we did was offer as many attack methods as possible - simple encoding ones like ROT13, leetspeak, to prompt injections, roleplay, and jailbreaking. We then heard folks weren\u2019t happy because the attacks didn\u2019t persist across tests and hence they \u201clost\u201d their progress every time they tested, and so we added an option to `reuse_simulated_attacks`.
We abstracted everything away to make it as modular as possible - every vulnerability, attack, can be imported in Python as `Bias(type=[\u201crace\u201d])`, `LinearJailbreaking()`, etc. with methods such as `.enhance()` for teams to plug-and-play, build their own test suite, and even to add a few more rounds of attack enhancements to increase the likelihood of breaking your system.
Notably, there are a few limitations. Users might run into compliance errors when attempting to simulate attacks (especially for AzureOpenAI), and so we recommend setting `ignore_errors` to `True` in case that happens. You might also run into bottlenecks where DeepTeam does not cover your custom vulnerability type, and so we shipped a `CustomVulnerability` class as a \u201ccatch-all\u201d solution (still in beta).
You might be aware that some packages already exist that do a similar thing, often known as \u201cvulnerability scanning\u201d or \u201cred teaming\u201d. The difference is that DeepTeam is modular, lightweight, and code friendly. Take Nvidia Garak for example, although comprehensive, has so many CLI rules, environments to set up, it is definitely not the easiest to get started, let alone pick the library apart to build your own penetration testing pipeline. In DeepTeam, define a class, wrap it around your own implementations if necessary, and you\u2019re good to go.
We adopted a Apache 2.0 license (for now, and probably in the foreseeable future too), so if you want to get started, `pip install deepteam`, use any LLM for simulation, and you\u2019ll get a full penetration report within 1 minute (assuming you\u2019re running things asynchronously). GitHub: https://github.com/confident-ai/deepteam
Excited to share DeepTeam with everyone here \u2013 let us know what you think!","title":"Show HN: DeepTeam \u2013 Penetration Testing for LLMs","updated_at":"2025-06-02T02:41:09Z","url":"https://github.com/confident-ai/deepteam"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"jeffreyip"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["deepeval"],"value":"Hi HN, we\u2019re Jeffrey and Kritin, and we\u2019re building DeepTeam (https://github.com/confident-ai/deepteam), an open-source Python library to scan LLM apps for security vulnerabilities. You can start \u201cpenetration testing\u201d by defining a Python callback to your LLM app (e.g. `def model_callback(input: str)`), and DeepTeam will attempt to probe it with prompts designed to elicit unsafe or unintended behavior.
Note that the penetration testing process treats your LLM app as a black-box - which means that DeepTeam will not know whether PII leakage has occurred in a certain tool call or incorporated in the training data of your fine-tuned LLM, but rather just detect that it is present. Internally, we call this process \u201cend-to-end\u201d testing.
Before DeepTeam, we worked on DeepEval, an open-source framework to unit-test LLMs. Some of you might be thinking, well isn\u2019t this kind of similar to unit-testing?
Sort of, but not really. While LLM unit-testing focuses on 1) accurate eval metrics, 2) comprehensive eval datasets, penetration testing focuses on the haphazard simulation of attacks, and the orchestration of it. To users, this was a big and confusing paradigm shift, because it went from \u201cDid this pass?\u201d to \u201cHow can this break?\u201d.
So we thought to ourselves, why not just release a new package to orchestrate the simulation of adversarial attacks for this new set of users and teams working specifically on AI safety, and borrow DeepEval\u2019s evals and ecosystem in the process?
Quickstart here: https://www.trydeepteam.com/docs/getting-started#detect-your-first-llm-vulnerability
The first thing we did was offer as many attack methods as possible - simple encoding ones like ROT13, leetspeak, to prompt injections, roleplay, and jailbreaking. We then heard folks weren\u2019t happy because the attacks didn\u2019t persist across tests and hence they \u201clost\u201d their progress every time they tested, and so we added an option to `reuse_simulated_attacks`.
We abstracted everything away to make it as modular as possible - every vulnerability, attack, can be imported in Python as `Bias(type=[\u201crace\u201d])`, `LinearJailbreaking()`, etc. with methods such as `.enhance()` for teams to plug-and-play, build their own test suite, and even to add a few more rounds of attack enhancements to increase the likelihood of breaking your system.
Notably, there are a few limitations. Users might run into compliance errors when attempting to simulate attacks (especially for AzureOpenAI), and so we recommend setting `ignore_errors` to `True` in case that happens. You might also run into bottlenecks where DeepTeam does not cover your custom vulnerability type, and so we shipped a `CustomVulnerability` class as a \u201ccatch-all\u201d solution (still in beta).
You might be aware that some packages already exist that do a similar thing, often known as \u201cvulnerability scanning\u201d or \u201cred teaming\u201d. The difference is that DeepTeam is modular, lightweight, and code friendly. Take Nvidia Garak for example, although comprehensive, has so many CLI rules, environments to set up, it is definitely not the easiest to get started, let alone pick the library apart to build your own penetration testing pipeline. In DeepTeam, define a class, wrap it around your own implementations if necessary, and you\u2019re good to go.
We adopted a Apache 2.0 license (for now, and probably in the foreseeable future too), so if you want to get started, `pip install deepteam`, use any LLM for simulation, and you\u2019ll get a full penetration report within 1 minute (assuming you\u2019re running things asynchronously). GitHub: https://github.com/confident-ai/deepteam
Excited to share DeepTeam with everyone here \u2013 let us know what you think!"},"title":{"matchLevel":"none","matchedWords":[],"value":"DeepTeam: Penetration Testing for LLMs"}},"_tags":["story","author_jeffreyip","story_44128270","ask_hn"],"author":"jeffreyip","created_at":"2025-05-29T17:35:12Z","created_at_i":1748540112,"num_comments":0,"objectID":"44128270","points":2,"story_id":44128270,"story_text":"Hi HN, we\u2019re Jeffrey and Kritin, and we\u2019re building DeepTeam (https://github.com/confident-ai/deepteam), an open-source Python library to scan LLM apps for security vulnerabilities. You can start \u201cpenetration testing\u201d by defining a Python callback to your LLM app (e.g. `def model_callback(input: str)`), and DeepTeam will attempt to probe it with prompts designed to elicit unsafe or unintended behavior.
Note that the penetration testing process treats your LLM app as a black-box - which means that DeepTeam will not know whether PII leakage has occurred in a certain tool call or incorporated in the training data of your fine-tuned LLM, but rather just detect that it is present. Internally, we call this process \u201cend-to-end\u201d testing.
Before DeepTeam, we worked on DeepEval, an open-source framework to unit-test LLMs. Some of you might be thinking, well isn\u2019t this kind of similar to unit-testing?
Sort of, but not really. While LLM unit-testing focuses on 1) accurate eval metrics, 2) comprehensive eval datasets, penetration testing focuses on the haphazard simulation of attacks, and the orchestration of it. To users, this was a big and confusing paradigm shift, because it went from \u201cDid this pass?\u201d to \u201cHow can this break?\u201d.
So we thought to ourselves, why not just release a new package to orchestrate the simulation of adversarial attacks for this new set of users and teams working specifically on AI safety, and borrow DeepEval\u2019s evals and ecosystem in the process?
Quickstart here: https://www.trydeepteam.com/docs/getting-started#detect-your-first-llm-vulnerability
The first thing we did was offer as many attack methods as possible - simple encoding ones like ROT13, leetspeak, to prompt injections, roleplay, and jailbreaking. We then heard folks weren\u2019t happy because the attacks didn\u2019t persist across tests and hence they \u201clost\u201d their progress every time they tested, and so we added an option to `reuse_simulated_attacks`.
We abstracted everything away to make it as modular as possible - every vulnerability, attack, can be imported in Python as `Bias(type=[\u201crace\u201d])`, `LinearJailbreaking()`, etc. with methods such as `.enhance()` for teams to plug-and-play, build their own test suite, and even to add a few more rounds of attack enhancements to increase the likelihood of breaking your system.
Notably, there are a few limitations. Users might run into compliance errors when attempting to simulate attacks (especially for AzureOpenAI), and so we recommend setting `ignore_errors` to `True` in case that happens. You might also run into bottlenecks where DeepTeam does not cover your custom vulnerability type, and so we shipped a `CustomVulnerability` class as a \u201ccatch-all\u201d solution (still in beta).
You might be aware that some packages already exist that do a similar thing, often known as \u201cvulnerability scanning\u201d or \u201cred teaming\u201d. The difference is that DeepTeam is modular, lightweight, and code friendly. Take Nvidia Garak for example, although comprehensive, has so many CLI rules, environments to set up, it is definitely not the easiest to get started, let alone pick the library apart to build your own penetration testing pipeline. In DeepTeam, define a class, wrap it around your own implementations if necessary, and you\u2019re good to go.
We adopted a Apache 2.0 license (for now, and probably in the foreseeable future too), so if you want to get started, `pip install deepteam`, use any LLM for simulation, and you\u2019ll get a full penetration report within 1 minute (assuming you\u2019re running things asynchronously). GitHub: https://github.com/confident-ai/deepteam
Excited to share DeepTeam with everyone here \u2013 let us know what you think!","title":"DeepTeam: Penetration Testing for LLMs","updated_at":"2025-05-29T23:18:42Z"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"dustfinger"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["deepeval"],"value":"I built a tag-driven changelog generator for an OSS project I maintain and used it to backfill our 2025 docs changelog.
It walks git tags, finds merged PRs between releases, buckets them into categories, and renders MDX (Docusaurus in our case) organized by year -> month -> category -> version. There is an optional LLM mode that produces structured JSON via a Pydantic schema for PR entry and monthly summaries.
Example:
python .scripts/changelog/generate.py --year 2025 --github --ai --ai-model gpt-5.2\n(or --help)
Gotcha: if you use --github, set GITHUB_TOKEN or you will most likely hit GitHub rate limits.
Repo script: https://github.com/confident-ai/deepeval/blob/main/.scripts/...
Disclosure: I maintain DeepEval. Happy to answer questions and take feedback."},"title":{"matchLevel":"none","matchedWords":[],"value":"Show HN: Tag driven changelog generator (MDX) with optional LLM summaries"}},"_tags":["story","author_dustfinger","story_46569948","show_hn"],"author":"dustfinger","children":[46578861],"created_at":"2026-01-10T21:10:51Z","created_at_i":1768079451,"num_comments":1,"objectID":"46569948","points":1,"story_id":46569948,"story_text":"I built a tag-driven changelog generator for an OSS project I maintain and used it to backfill our 2025 docs changelog.
It walks git tags, finds merged PRs between releases, buckets them into categories, and renders MDX (Docusaurus in our case) organized by year -> month -> category -> version. There is an optional LLM mode that produces structured JSON via a Pydantic schema for PR entry and monthly summaries.
Example:
python .scripts/changelog/generate.py --year 2025 --github --ai --ai-model gpt-5.2\n(or --help)
Gotcha: if you use --github, set GITHUB_TOKEN or you will most likely hit GitHub rate limits.
Repo script: https://github.com/confident-ai/deepeval/blob/main/.scripts/...
Disclosure: I maintain DeepEval. Happy to answer questions and take feedback.","title":"Show HN: Tag driven changelog generator (MDX) with optional LLM summaries","updated_at":"2026-03-05T23:20:53Z"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"jeffreyip"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["deepeval"],"value":"Hi HN, we\u2019re Jeffrey and Kritin, and we\u2019re building DeepTeam (https://github.com/confident-ai/deepteam), an open-source Python library to scan LLM apps for security vulnerabilities. You can start \u201cpenetration testing\u201d by defining a Python callback to your LLM app (e.g. `def model_callback(input: str)`), and DeepTeam will attempt to probe it with prompts designed to elicit unsafe or unintended behavior.\nNote that the penetration testing process treats your LLM app as a black-box - which means that DeepTeam will not know whether PII leakage has occurred in a certain tool call or incorporated in the training data of your fine-tuned LLM, but rather just detect that it is present. Internally, we call this process \u201cend-to-end\u201d testing.
Before DeepTeam, we worked on DeepEval, an open-source framework to unit-test LLMs. Some of you might be thinking, well isn\u2019t this kind of similar to unit-testing?
Sort of, but not really. While LLM unit-testing focuses on 1) accurate eval metrics, 2) comprehensive eval datasets, penetration testing focuses on the haphazard simulation of attacks, and the orchestration of it. To users, this was a big and confusing paradigm shift, because it went from \u201cDid this pass?\u201d to \u201cHow can this break?\u201d.
So we thought to ourselves, why not just release a new package to orchestrate the simulation of adversarial attacks for this new set of users and teams working specifically on AI safety, and borrow DeepEval\u2019s evals and ecosystem in the process?
Quickstart here: https://www.trydeepteam.com/docs/getting-started#detect-your-first-llm-vulnerability
The first thing we did was offer as many attack methods as possible - simple encoding ones like ROT13, leetspeak, to prompt injections, roleplay, and jailbreaking. We then heard folks weren\u2019t happy because the attacks didn\u2019t persist across tests and hence they \u201clost\u201d their progress every time they tested, and so we added an option to `reuse_simulated_attacks`.
We abstracted everything away to make it as modular as possible - every vulnerability, attack, can be imported in Python as `Bias(type=[\u201crace\u201d])`, `LinearJailbreaking()`, etc. with methods such as `.enhance()` for teams to plug-and-play, build their own test suite, and even to add a few more rounds of attack enhancements to increase the likelihood of breaking your system.
Notably, there are a few limitations. Users might run into compliance errors when attempting to simulate attacks (especially for AzureOpenAI), and so we recommend setting `ignore_errors` to `True` in case that happens. You might also run into bottlenecks where DeepTeam does not cover your custom vulnerability type, and so we shipped a `CustomVulnerability` class as a \u201ccatch-all\u201d solution (still in beta).
You might be aware that some packages already exist that do a similar thing, often known as \u201cvulnerability scanning\u201d or \u201cred teaming\u201d. The difference is that DeepTeam is modular, lightweight, and code friendly. Take Nvidia Garak for example, although comprehensive, has so many CLI rules, environments to set up, it is definitely not the easiest to get started, let alone pick the library apart to build your own penetration testing pipeline. In DeepTeam, define a class, wrap it around your own implementations if necessary, and you\u2019re good to go.
We adopted a Apache 2.0 license (for now, and probably in the foreseeable future too), so if you want to get started, `pip install deepteam`, use any LLM for simulation, and you\u2019ll get a full penetration report within 1 minute (assuming you\u2019re running things asynchronously). GitHub: https://github.com/confident-ai/deepteam
Excited to share DeepTeam with everyone here \u2013 let us know what you think!"},"title":{"matchLevel":"none","matchedWords":[],"value":"DeepTeam: Open-Source Pennetration Testing for LLMs"}},"_tags":["story","author_jeffreyip","story_44124610","ask_hn"],"author":"jeffreyip","created_at":"2025-05-29T10:21:59Z","created_at_i":1748514119,"num_comments":0,"objectID":"44124610","points":1,"story_id":44124610,"story_text":"Hi HN, we\u2019re Jeffrey and Kritin, and we\u2019re building DeepTeam (https://github.com/confident-ai/deepteam), an open-source Python library to scan LLM apps for security vulnerabilities. You can start \u201cpenetration testing\u201d by defining a Python callback to your LLM app (e.g. `def model_callback(input: str)`), and DeepTeam will attempt to probe it with prompts designed to elicit unsafe or unintended behavior.\nNote that the penetration testing process treats your LLM app as a black-box - which means that DeepTeam will not know whether PII leakage has occurred in a certain tool call or incorporated in the training data of your fine-tuned LLM, but rather just detect that it is present. Internally, we call this process \u201cend-to-end\u201d testing.
Before DeepTeam, we worked on DeepEval, an open-source framework to unit-test LLMs. Some of you might be thinking, well isn\u2019t this kind of similar to unit-testing?
Sort of, but not really. While LLM unit-testing focuses on 1) accurate eval metrics, 2) comprehensive eval datasets, penetration testing focuses on the haphazard simulation of attacks, and the orchestration of it. To users, this was a big and confusing paradigm shift, because it went from \u201cDid this pass?\u201d to \u201cHow can this break?\u201d.
So we thought to ourselves, why not just release a new package to orchestrate the simulation of adversarial attacks for this new set of users and teams working specifically on AI safety, and borrow DeepEval\u2019s evals and ecosystem in the process?
Quickstart here: https://www.trydeepteam.com/docs/getting-started#detect-your-first-llm-vulnerability
The first thing we did was offer as many attack methods as possible - simple encoding ones like ROT13, leetspeak, to prompt injections, roleplay, and jailbreaking. We then heard folks weren\u2019t happy because the attacks didn\u2019t persist across tests and hence they \u201clost\u201d their progress every time they tested, and so we added an option to `reuse_simulated_attacks`.
We abstracted everything away to make it as modular as possible - every vulnerability, attack, can be imported in Python as `Bias(type=[\u201crace\u201d])`, `LinearJailbreaking()`, etc. with methods such as `.enhance()` for teams to plug-and-play, build their own test suite, and even to add a few more rounds of attack enhancements to increase the likelihood of breaking your system.
Notably, there are a few limitations. Users might run into compliance errors when attempting to simulate attacks (especially for AzureOpenAI), and so we recommend setting `ignore_errors` to `True` in case that happens. You might also run into bottlenecks where DeepTeam does not cover your custom vulnerability type, and so we shipped a `CustomVulnerability` class as a \u201ccatch-all\u201d solution (still in beta).
You might be aware that some packages already exist that do a similar thing, often known as \u201cvulnerability scanning\u201d or \u201cred teaming\u201d. The difference is that DeepTeam is modular, lightweight, and code friendly. Take Nvidia Garak for example, although comprehensive, has so many CLI rules, environments to set up, it is definitely not the easiest to get started, let alone pick the library apart to build your own penetration testing pipeline. In DeepTeam, define a class, wrap it around your own implementations if necessary, and you\u2019re good to go.
We adopted a Apache 2.0 license (for now, and probably in the foreseeable future too), so if you want to get started, `pip install deepteam`, use any LLM for simulation, and you\u2019ll get a full penetration report within 1 minute (assuming you\u2019re running things asynchronously). GitHub: https://github.com/confident-ai/deepteam
Excited to share DeepTeam with everyone here \u2013 let us know what you think!","title":"DeepTeam: Open-Source Pennetration Testing for LLMs","updated_at":"2025-05-29T10:24:39Z"}],"hitsPerPage":20,"nbHits":341,"nbPages":18,"page":0,"params":"query=deepeval&advancedSyntax=true&analyticsTags=backend","processingTimeMS":9,"processingTimingsMS":{"_request":{"queue":100,"roundTrip":22},"afterFetch":{"format":{"highlighting":1,"total":1}},"fetch":{"query":7,"total":8},"total":9},"query":"deepeval","serverTimeMS":112}