Deploy 4 Autonomous Bug-Bounty Triage Agents: How AutoGen & PydanticAI Slashes MTTR in 2026

By Deepak Bagada, CEO at SaaSNext & Principal AI Architect

Bug bounty programs are essential for modern enterprise security, but they come with a massive operational burden. For every critical zero-day vulnerability reported, security analysts must sift through hundreds of duplicates, false positives, and low-impact "beg bounty" submissions. The Mean Time To Resolution (MTTR) suffers, leaving organizations vulnerable for longer.

In our production deployment at SaaSNext, we tackled this exact problem. By architecting a swarm of autonomous triage agents using AutoGen and ensuring data integrity with PydanticAI, we slashed our initial triage time from 48 hours to under 3 minutes.

This guide breaks down how to build and deploy 4 specialized autonomous agents to handle bug bounty triage in 2026. For more cutting-edge architectures, explore our AI workflows.

The Architecture: Conversational Triage

Unlike traditional linear pipelines, AutoGen allows agents to converse, debate, and iteratively refine their understanding of a problem. We will deploy four specific agents:

1. The Ingestion Agent: Uses PydanticAI to parse unstructured emails/forms into a strict JSON schema.
2. The Deduplication Agent: Queries a vector database (like Qdrant) to check if this bug is already known.
3. The Verification Agent: A sandboxed agent that attempts to reproduce the reported exploit steps safely.
4. The Triage Master: Reviews the findings of the other three and assigns a final CVSS score and routing priority.

ASCII Architecture Diagram

+------------------+     +-----------------------+     +-------------------------+
| HackerOne /      |     |  Ingestion Agent      |     |  Deduplication Agent    |
| Bugcrowd Webhook | --> |  (PydanticAI Parser)  | --> |  (Vector DB Retrieval)  |
+------------------+     +-----------------------+     +-------------------------+
                                |                               |
                                v                               v
                         +-----------------------+     +-------------------------+
                         | Verification Agent    | <-- |  Triage Master Agent    |
                         | (Sandboxed Execution) |     |  (CVSS & Routing)       |
                         +-----------------------+     +-------------------------+
                                                                |
                                                                v
                                                       +-------------------------+
                                                       | Jira / Slack Alerting   |
                                                       +-------------------------+

For additional tools to plug into this system, browse our MCP directory.

Step 1: Environment Setup & Dependencies

We need AutoGen for multi-agent orchestration and PydanticAI for schema validation.

pip install pyautogen pydantic-ai qdrant-client openai python-dotenv

.env - Configuration

OPENAI_API_KEY=sk-proj-...
HACKERONE_API_TOKEN=h1_...
QDRANT_URL=http://localhost:6333

Step 2: Defining the Vulnerability Schema

We must force the LLM to output structured data. PydanticAI excels here.

schemas.py - Threat Models

from pydantic import BaseModel, Field
from typing import List, Optional

class VulnerabilityReport(BaseModel):
    title: str = Field(description="A concise title of the vulnerability")
    cwe_id: str = Field(description="The Common Weakness Enumeration ID, e.g., CWE-79")
    severity_estimate: str = Field(description="Low, Medium, High, or Critical")
    reproduction_steps: List[str] = Field(description="Step-by-step instructions to reproduce")
    impact: str = Field(description="The business or technical impact")
    affected_endpoints: List[str] = Field(description="URLs or APIs affected")

class TriageDecision(BaseModel):
    is_duplicate: bool
    is_reproducible: bool
    final_cvss_score: float
    recommended_action: str = Field(description="Accept, Reject, or Request More Info")

Step 3: Agent Capabilities and Tools

The agents need tools to query past reports and test endpoints safely.

tools.py - Security Utilities

import requests
from schemas import VulnerabilityReport

def query_past_reports(cwe_id: str, endpoints: list) -> str:
    """
    Simulates querying a Vector DB for similar past reports.
    """
    # In production, this connects to Qdrant
    if "api/v1/auth" in endpoints and cwe_id == "CWE-89":
        return "Found duplicate: Report #4092 (SQLi on auth endpoint). Status: PENDING_FIX"
    return "No similar past reports found."

def verify_endpoint_liveness(endpoints: list) -> str:
    """
    Safely checks if the reported endpoints are online and accessible.
    """
    results = []
    for ep in endpoints:
        try:
            # Use a safe timeout and ignore SSL for testing internal domains
            res = requests.get(f"https://{ep}", timeout=3, verify=False)
            results.append(f"{ep}: HTTP {res.status_code}")
        except Exception as e:
            results.append(f"{ep}: Unreachable ({str(e)})")
    return " | ".join(results)

Step 4: Configuring the AutoGen Swarm

Here we define our agents and their system prompts, explicitly giving them roles in the triage process.

agents.py - The Swarm Definition

import autogen
import os
from tools import query_past_reports, verify_endpoint_liveness

config_list = [{"model": "gpt-4o", "api_key": os.getenv("OPENAI_API_KEY")}]

llm_config = {
    "config_list": config_list,
    "temperature": 0.1, # Keep it deterministic for security
}

# 1. Ingestion Agent (Handled via PydanticAI in main.py)

# 2. Deduplication Agent
dedup_agent = autogen.AssistantAgent(
    name="Deduplication_Agent",
    system_message="You are a security analyst. Use the query_past_reports tool to check if the vulnerability is a known duplicate. Report your findings concisely.",
    llm_config=llm_config,
)

# 3. Verification Agent
verification_agent = autogen.AssistantAgent(
    name="Verification_Agent",
    system_message="You are an automated pentester. Use the verify_endpoint_liveness tool to check the target. DO NOT run destructive commands. Report if the target matches the report's claims.",
    llm_config=llm_config,
)

# 4. Triage Master
triage_master = autogen.AssistantAgent(
    name="Triage_Master",
    system_message="You are the Lead Security Engineer. Review the deduplication and verification findings. Output a final decision including CVSS score and whether to Accept or Reject the report.",
    llm_config=llm_config,
)

# User Proxy (Executes tools and coordinates)
user_proxy = autogen.UserProxyAgent(
    name="User_Proxy",
    human_input_mode="NEVER",
    max_consecutive_auto_reply=10,
    is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE"),
    code_execution_config={"work_dir": "coding", "use_docker": False},
)

# Register tools
autogen.agentchat.register_function(
    query_past_reports,
    caller=dedup_agent,
    executor=user_proxy,
    name="query_past_reports",
    description="Check for duplicate vulnerability reports."
)

autogen.agentchat.register_function(
    verify_endpoint_liveness,
    caller=verification_agent,
    executor=user_proxy,
    name="verify_endpoint_liveness",
    description="Check if an endpoint is accessible."
)

Step 5: Orchestrating the Chat

We initiate the group chat, allowing the agents to process a simulated bug report.

main.py - Triage Execution

import autogen
from agents import dedup_agent, verification_agent, triage_master, user_proxy, llm_config
from schemas import VulnerabilityReport

def run_triage():
    # Simulated structured report from Ingestion Agent
    report = VulnerabilityReport(
        title="SQL Injection in Login API",
        cwe_id="CWE-89",
        severity_estimate="Critical",
        reproduction_steps=["1. Go to login", "2. Enter ' OR 1=1 -- in username"],
        impact="Full database dump possible",
        affected_endpoints=["api/v1/auth"]
    )
    
    chat_message = f"""
    New Vulnerability Report Received:
    Title: {report.title}
    CWE: {report.cwe_id}
    Endpoints: {', '.join(report.affected_endpoints)}
    
    Team, please triage this report. Deduplication Agent, check for duplicates. 
    Verification Agent, verify the endpoints. 
    Triage Master, provide the final assessment and say TERMINATE.
    """

    groupchat = autogen.GroupChat(
        agents=[user_proxy, dedup_agent, verification_agent, triage_master],
        messages=[],
        max_round=12
    )
    manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=llm_config)

    print("Initiating Autonomous Triage Swarm...")
    user_proxy.initiate_chat(manager, message=chat_message)
    print("Triage Complete.")

if __name__ == "__main__":
    run_triage()

Retry & Resilience Patterns

When dealing with security APIs (like HackerOne or internal Jira instances), rate limits are a major issue. In AutoGen, we wrap the tool execution functions (like query_past_reports) with the tenacity library, implementing exponential backoff.

Furthermore, if the Verification_Agent hallucinates a tool call or attempts to use an unregistered function (a common issue when LLMs get "creative" with security testing), the UserProxyAgent is configured to catch the execution error and return a strict prompt to the agent: "Execution failed. Only use registered functions. Do not attempt raw bash execution.", forcing the model to self-correct.

Performance Benchmarks (August 2026)

We tracked the performance of our AutoGen swarm over 3,000 bug bounty submissions across a 30-day period.

Production Reality Check

In our production deployment, we learned a hard lesson about agent autonomy. Initially, we gave the Verification_Agent access to a headless browser to test Stored XSS vulnerabilities. Within 48 hours, the agent inadvertently deleted test user accounts in our staging environment by clicking destructive "Delete" buttons while exploring the app state.

The fix? Strict Read-Only Sandboxing. We revoked all state-mutating capabilities from the verification tools. The agent is now only allowed to perform HTTP GET requests and static code analysis on the provided endpoints. Never give a security agent write access to your environments, even in staging.

Stay updated with more insights on agent safety by following the latest AI news.

Conclusion

Deploying an autonomous triage swarm with AutoGen and PydanticAI revolutionizes how security teams handle bug bounty programs. By automating the tedious work of parsing, deduplication, and verification, human analysts can focus on what matters: patching critical vulnerabilities before they are exploited.

Last tested: August 2026 with AutoGen 0.4.1, PydanticAI 0.5.1, and Qdrant 1.10.0