AI-Powered AppSec: 10x Your Security Team Without Scaling Headcount

AI-Powered AppSec: 10x Your Security Team Without Scaling Headcount

Speakers: Anshuman Bhartiya

Conference: BSides SF

YouTube: https://www.youtube.com/watch?v=yN2PgbUPsm8

Overview

Anshuman Bhartiya, AppSec Tech Lead at Lyft, presented a compelling talk on leveraging Artificial Intelligence to dramatically enhance application security capabilities without the need for proportional headcount increases. Titled "AI-Powered AppSec: 10x Your Security Team Without Scaling Headcount," the session at BSides SF delved into how AI can serve as a force multiplier, tackling the pervasive "security scaling crisis" that plagues modern software development. Bhartiya introduced Priscia, an internal platform developed at Lyft, showcasing its practical application in three critical AppSec domains: automated pull request (PR) security analysis, intelligent Static Application Security Testing (SAST) triage, and AI-powered AppSec design review automation.

The core premise of Bhartiya's presentation is that traditional methods of scaling AppSec – hiring more engineers, acquiring more tools, or simply prioritizing – are no longer sufficient to keep pace with the explosion of code generation, especially with the advent of AI-assisted development. By reframing AI not as a job replacement but as an enabler, security teams can offload repetitive, time-consuming tasks to intelligent agents, freeing human experts to focus on complex problems requiring deep analytical thought and strategic decision-making. This approach promises to bridge the growing gap between development velocity and security coverage, making AppSec more efficient, consistent, and proactive.

Background

▶ Watch: Introduction to speaker and AppSec passion (0:00)

The "security scaling crisis" is a fundamental challenge for application security teams today. Bhartiya highlights several symptoms: hundreds of pull requests (PRs) merged daily, a deluge of SAST findings, the inability to perform timely and comprehensive design reviews, and engineering teams often waiting for security feedback. This crisis existed even before the widespread adoption of generative AI, but the proliferation of AI-generated code has exacerbated the problem. While AI can accelerate development, the code it produces is not inherently secure and requires diligent review, further straining already overstretched security resources. The industry observes a disconnect: more code and more potential vulnerabilities are generated, yet security teams often operate with stagnant or even shrinking headcounts.

Traditional attempts to address this scaling issue have proven inadequate. Hiring more people is often not feasible or sustainable. Acquiring more security tools merely adds to the noise, generating more alerts that still require human analysis. Prioritization, while necessary, often lacks a clear, consistent framework that aligns with engineering realities, leading to misalignment and eroded trust. Furthermore, the "shift left" paradigm, while noble, often fails at scale; simply training engineers in threat modeling, for instance, rarely translates into consistent, high-quality security practices across an entire organization. These systemic failures underscore the urgent need for a paradigm shift in how AppSec is approached, leading Bhartiya and his team to explore AI as a fundamental solution.

Key Findings

▶ Watch: Defining the security scaling crisis with AI (3:10)

The implementation of the Priscia platform at Lyft, as detailed by Bhartiya, yielded significant and tangible results across its three primary use cases:

1. Automated PR Security Analysis: Despite traditional tools often missing high-impact vulnerabilities, Priscia successfully identified 30 true positives in first-party code over an eight-week period. These findings included 4 critical, 16 high, and 10 medium severity vulnerabilities. Crucially, these were issues that no existing scanner had detected, predominantly related to authentication, authorization, IDOR (Insecure Direct Object Reference), forced browsing, and horizontal privilege escalation. These are complex, context-dependent vulnerabilities that typically require human expertise to uncover, demonstrating AI's capability to identify deep-seated logic flaws.

1. Intelligent SAST Triage: Priscia dramatically improved the efficiency and consistency of SAST finding triage. Before AI, manual triage consumed significant security engineer time (30 minutes to hours per finding), suffered from inconsistency based on the triaging engineer's experience, and lacked deep context. After implementing AI, the agents autonomously perform detailed risk assessments, authentication analysis, and external exposure checks, leading to more accurate severity ratings and SLAs. This shift eliminated human involvement in the initial triage, ensuring consistent and detailed reasoning across all findings, and freeing engineers to focus on remediation rather than investigation.

1. AI-Powered AppSec Design Review Automation: Initially a significant bottleneck, design reviews, which previously took days for manual analysis of lengthy specifications, were reduced to mere minutes. The AI agent provides initial security insights and questions, allowing engineers to quickly understand potential issues related to authentication, authorization, sensitive data handling, and logging. This automation enabled comprehensive coverage, ensuring every design specification received a security review, moving from reviewing "only high priorities" to "every spec gets reviewed now." It also allowed for deeper verification of engineering claims, moving beyond just trusting answers to actively verifying security best practices.

These findings collectively demonstrate that AI can effectively act as a force multiplier, not only by automating repetitive tasks but also by uncovering sophisticated vulnerabilities and providing a level of consistency and depth that is challenging to achieve with human effort alone, especially at scale.

Technical Deep Dive

▶ Watch: Specific challenges faced by AppSec teams (4:30)

The Priscia platform at Lyft is engineered to address the security scaling crisis through an agent-based architecture leveraging multiple Large Language Models (LLMs) and intelligent context engineering. The platform's architecture is straightforward yet powerful: events from a SIM platform trigger webhooks that feed into Priscia. Within Priscia, a growing suite of AI agents (six as of the talk, with three detailed) perform specialized security analyses.

The core technical principles underpinning Priscia's design include:

• Flask Backend: Provides the web interface and API for interacting with the platform.
• DynamoDB: Used for storing artifacts, logs, and other persistent data generated by the agents.
• Multiple LLMs: Acknowledging the non-determinism inherent in LLMs, Priscia employs multiple models (e.g., Sonnet and GPT, or more recently Opus and GPT) for the same workflow. This allows for a consensus mechanism to validate findings, enhancing reliability.
• Async Processing: Agents are designed to run autonomously for extended periods, necessitating an asynchronous processing model to avoid blocking operations and ensure scalability. This is achieved by dropping jobs into a queue, picked up by workers.

Automated PR Security Analysis Agent

This agent focuses on high-impact vulnerabilities. Its workflow comprises multiple phases:

1. Route Extraction: Identifies new, changed, or removed API endpoints within a PR.
2. Authentication/Authorization Signal Detection: Analyzes code changes for their impact on authentication components, role management, and access controls. This is done by sending targeted queries to LLMs.
3. Multi-Model Consensus: The output from parallel LLM runs is compared. Bhartiya describes an early prototype consensus mechanism: two models (e.g., Sonnet with 60% weight, GPT with 40%) must both agree, and their combined consensus score must exceed 50% for a finding to be generated. This helps bridge the "variance factor" and improve the determinism of AI-based systems.
4. Finding Generation: If consensus is met, a security finding is generated.
5. Smart Route Filtering: To optimize token usage and focus on critical areas, the agent filters out irrelevant code changes, such as health check endpoints or changes related to accepted organizational risks. This ensures the LLM focuses on "keys to the kingdom" and high-value components, rather than holistic coverage initially.

SAST Triage Agent

This agent addresses the overwhelming volume and often inaccurate severity of traditional SAST tools. It uses code context to reason about findings:

1. Contextual Enrichment: When a SAST tool flags a vulnerability (e.g., SQL injection), the agent doesn't just look at the line of code. It integrates with Sourcegraph (a code intelligence platform) or similar tools to gather broader code context.
2. Risk Assessment: The agent evaluates the finding against the organization's specific priorities and existing controls, rather than relying solely on the SAST tool's generic severity.
3. Authentication Analysis: Determines if the vulnerable endpoint requires authentication and what level of authentication is present.
4. Data Access Analysis: Checks if the endpoint accesses sensitive customer data.
5. Best Practice Verification: Compares the implementation against Lyft's internal security best practices for authentication and other controls.
6. External Exposure Check: Crucially, it determines if the vulnerable component is externally exposed. A vulnerability in an internal-only service might have a lower severity and different SLA than one exposed to the internet.

This comprehensive reasoning allows the agent to provide a highly accurate and context-aware triage, significantly improving on manual processes.

AI-Powered AppSec Design Review Agent

This agent automates the review of lengthy design specifications. The V1 architecture is more sophisticated:

1. Flask UI: Engineers submit Google Doc URLs for review.
2. Lyft Agent Runtime Environment: Leverages Lyft's mature ML platform for agent execution, observability, and infrastructure management.
3. Queued Job Processing: A job is dropped into a queue and picked up by a worker.
4. Multi-Step Analysis: The agent performs several sequential steps:

• Downloads and parses the document.
• Analyzes architecture diagrams (using techniques to extract information from visual representations).
• Performs threat modeling.
• Conducts GDPR analysis (or other compliance checks).
• Synthesizes all findings into a structured output.

This multi-stage approach guides the LLM to process complex, multi-modal input (text and diagrams) and derive specific security insights, which are then stored for review.

Key Learnings in Agent Development

Bhartiya shared several crucial lessons for building effective AI-powered security systems:

• Two LLMs for Consensus: Running the same workflow through different LLMs and comparing outputs significantly reduces variance and increases confidence.
• Code Context is King: Integrating with code intelligence platforms (like Sourcegraph via its LSP server) provides the necessary context for LLMs to reason effectively about code.
• Structured Output: Defining a clear JSON output structure for LLM responses is vital for reliable parsing and subsequent processing. Techniques like "hooks" (e.g., in Claude) can enforce this.
• Reducing Noise: Smart filtering (e.g., smart route filtering in PR analysis) and focusing on "keys to the kingdom" optimizes token usage and directs LLMs to critical areas.
• Skills: Developing "skills" – small, reusable prompts or code snippets that teach an agent how to perform a specific security task (e.g., finding a type of vulnerability, triaging an issue) – empowers agents to emulate human expertise.
• Iterative Prompt Refinement: Creating a feedback loop where the AI helps refine its own prompts based on desired outcomes (e.g., "this is the outcome I want, this is where we are, help me refine the prompt") is highly effective for complex tasks.
• Cost Management: Being strategic about what information is sent to LLMs (e.g., not entire PR diffs) is critical, as LLM token usage can be expensive, especially with frontier models like Opus.
• Bias to Action & Prototyping: Rapid prototyping ("v-coding") and demonstrating working UIs are essential for gaining buy-in and proving value within an organization.

Demo / Proof of Concept

▶ Watch: Framing AI as a security team force multiplier (6:55)

While the talk primarily focused on the internal Priscia platform at Lyft, Anshuman Bhartiya demonstrated the general applicability of his SAST triage framework by open-sourcing a tool called run_vibes. This tool serves as a practical proof-of-concept for how an AI agent can reason about security vulnerabilities in a microservice environment.

The run_vibes tool was built with a specific lab environment in mind, comprising four interconnected microservices: an auth service, a doc API, a front-end app, and an in-ops service. Bhartiya created pull requests in each of these repositories, introducing potential security vulnerabilities. The run_vibes agent was then tasked with analyzing these PRs to identify security flaws.

The agent's workflow in run_vibes mirrors the principles applied in Priscia's SAST triage:

1. Threat Modeling: It first performs an initial threat model of the changes within the PR to understand potential risks.
2. Vulnerability Identification: It then identifies specific security vulnerabilities.
3. Infrastructure Control Assessment: Crucially, it goes a step further by checking if existing infrastructure security controls might render an identified vulnerability unexploitable. This contextual understanding is vital for accurate triage and prioritization.

Bhartiya encouraged attendees to explore run_vibes on his GitHub, emphasizing that it's an experimental agent but demonstrates how one can use tools like Cloud Code or Cursor to understand and apply this framework. This open-source contribution provides a concrete example for other AppSec teams looking to build similar AI-powered solutions, showcasing the agent's ability to reason across different repositories and consider environmental factors beyond just the code itself.

Defensive Implications

▶ Watch: Introducing Lyft's Priscia platform and AI use cases (7:37)

The insights shared by Anshuman Bhartiya offer several critical implications for security defenders seeking to enhance their capabilities in an AI-driven world:

1. Embrace AI as a Force Multiplier: Defenders must shift their mindset from viewing AI as a job threat to seeing it as a powerful tool to augment their existing skills. AI can automate tedious, repetitive tasks, allowing human security engineers to focus on higher-level strategic work, complex problem-solving, and building relationships. This strategic adoption is key to scaling security efforts without proportional headcount increases.

1. Focus on High-Impact Vulnerabilities First: When starting with AI, prioritize use cases that address the most critical and difficult-to-find vulnerabilities (e.g., authentication/authorization bypasses, IDORs, privilege escalations). This approach not only demonstrates immediate value but also helps in refining the AI system where human expertise is most challenged. Don't aim for holistic coverage initially; focus on what truly matters to the organization's threat model.

1. Iterate on Real Vulnerabilities for Prompt Refinement: Building effective AI agents is an iterative process. Defenders should establish a feedback loop where the AI's output is continuously evaluated against real vulnerabilities. When the AI fails, use that failure to refine prompts, provide more context, or even ask the AI to suggest prompt improvements. This "outcome engineering" approach is crucial for achieving desired results and improving accuracy over time.

1. Manage Trust and False Positives Actively: Introducing AI into security workflows can erode trust if not managed carefully. Initially, operate AI systems passively (e.g., not blocking PRs) and keep a human in the loop to verify findings. When false positives occur, address them promptly and use them as learning opportunities for the AI. Cultivate a culture where security is seen as an enabler, not a blocker, by demonstrating the AI's value and accuracy.

1. Prioritize Context Engineering and Cost Optimization: The quality of AI output is directly tied to the context provided. Invest in context engineering, integrating AI agents with internal knowledge bases, code intelligence platforms (like Sourcegraph), and organizational-specific security policies. Simultaneously, be mindful of LLM token costs. Implement strategies like smart route filtering and targeted analysis to reduce noise and ensure only relevant information is sent to the LLM, making the solution economically viable.

1. Integrate AI into Existing Workflows: For AI solutions to be effective, they must seamlessly integrate into existing CI/CD pipelines, vulnerability management systems, and engineering workflows. Building AI agents in isolation then bolting them on will likely lead to resistance. Plan for integration early to ensure smooth adoption and maximize impact.

1. Bias to Action and Rapid Prototyping: Don't wait for a perfect solution. Encourage rapid prototyping ("v-coding") and experimentation with available LLMs. Even simple prototypes can quickly demonstrate value and gather essential feedback. Visualizing AI's reasoning and findings through user interfaces can be instrumental in gaining organizational buy-in and traction.

1. Develop "Skills" for AI Agents: Security engineers should start documenting their expertise in the form of "skills" or structured prompts that AI agents can learn from. This involves breaking down complex security tasks into discrete, actionable steps that an LLM can emulate. This enables the codification and scaling of human knowledge.

By adopting these defensive implications, security teams can proactively address the challenges of modern software development, leverage AI to amplify their impact, and set new standards for application security in their organizations.

Key Takeaways

• AI is a Force Multiplier, Not a Replacement: AI can 10x a security team's output by automating repetitive tasks, allowing human engineers to focus on complex, high-value problems and strategic thinking.
• Context is King for AI Accuracy: Providing rich code context, organizational policies, and infrastructure details (e.g., via Sourcegraph) is crucial for AI agents to reason effectively and accurately about security findings.
• Multi-LLM Consensus Improves Reliability: Using multiple LLMs (e.g., Sonnet, GPT, Opus) and a consensus mechanism helps mitigate the non-determinism of AI, leading to more consistent and trustworthy results.
• Iterative Development and Prompt Engineering are Essential: Building AI-powered AppSec solutions requires starting small, continuously iterating on prototypes, and refining prompts based on real-world outcomes and feedback from engineers.
• AI Can Find High-Impact, Logic-Based Vulnerabilities: AI agents can go beyond traditional keyword-based scanners to identify complex authentication, authorization, IDOR, and privilege escalation issues that typically require deep human analysis.
• Automated Triage and Design Reviews Drive Efficiency: AI can drastically reduce the time spent on SAST triage and design reviews, improving consistency, coverage, and allowing security teams to be more proactive at earlier stages of the SDLC.

About the Speaker(s)

Anshuman Bhartiya is the AppSec Tech Lead at Lyft, where he is at the forefront of leveraging AI to scale application security efforts. With 15-16 years of experience in the cybersecurity industry, Anshuman has a diverse background spanning both offensive and defensive security roles across various companies, from startups to large enterprises. His expertise covers cloud security, incident response, and application security, with AppSec being his particular passion due to its complex challenges involving not just tools but also human relationships and problem understanding. He is also actively involved in the "Boring AppSec" community and shares his insights and experiments with AI on his website, anshuman.ai.