Aakash Abhay Yadav
Managing CyberSecurity GRC | OWASP AI Exchange Author
San Francisco, California, United States
Actions
Aakash Abhay Yadav works on making security risk intelligence practical at enterprise scale and is an OWASP AI Exchange Author. He focuses on AI security, agentic risk, third party AI exposure, tool chain vulnerabilities, and runtime controls that teams can deploy in real environments. His work helps security and engineering teams translate emerging AI threats into actionable controls, detection logic, and architecture decisions.
Links
Area of Expertise
Topics
Runtime Enforcement for AI Agent Tool Calls, Because Reviewing Tools Isn't Reviewing Actions
Session Description
Your AI coding agents can now connect to any MCP tool server , databases, Slack, Jira, cloud APIs. Security teams review the tool. But nobody reviews the thousands of actions the agent takes through that tool at runtime. One bad tool call exfiltrates customer PII to a Slack channel, and your GRC review never saw it coming.
Portcullis is an open-source MCP stdio proxy (~280 lines of Go) that intercepts every tool call an agent makes, classifies it by data sensitivity (DCL tagging), tracks session taint across calls (if you touched Confidential data, your session is now tainted), and evaluates every action against OPA/Rego policy , all in under 2ms. The agent never knows enforcement is happening.
This is a live-demo talk. I will show: an agent reading a Confidential customer record, then attempting to post to Slack , and getting blocked because the session is tainted. Same session, same taint, but a Jira write succeeds because internal tools are allowed. GRC changes the policy by editing one Rego file. Zero deployments. Zero agent code changes.
Key Learnings
• Why tool-level review fails at runtime , the gap between approving a tool and controlling what an agent does with it
• How session taint propagation catches indirect data exfiltration that argument-level inspection misses
• Building a policy-as-code enforcement layer for MCP using OPA/Rego with <2ms evaluation latency
• Separating GRC policy ownership from developer tool connectivity , the 'blank cheque' model
• Open-source architecture walkthrough: Go proxy, Rego policies, audit trail, zero external dependencies
Portcullis: Runtime Enforcement for AI Agent Tool Calls, Because Reviewing Tools Isn't Reviewing Act
AI agents are increasingly given direct access to tools: shells, APIs, file systems, browsers. Most current safety reviews stop at "is this tool safe to expose?" — but a tool's risk isn't fixed; it's defined by how it's invoked at runtime. A file-write tool used to save a log is fine. The same tool used to overwrite /etc/passwd is not. This talk introduces Portcullis, a research prototype for runtime enforcement of agent tool calls — policy checks that evaluate the actual call (arguments, context, sequence) rather than just the tool's existence. We'll cover the threat model, where static tool-allowlisting fails, the enforcement architecture, and open problems in policy expressiveness and latency tradeoffs.
GRC-as-Code: How Security Teams Can Ship AI Governance Without Slowing Down Engineering
Security governance for AI systems is stuck in 2015. GRC teams write PDF policies. Engineering teams ignore them. When a developer wants to connect a new tool to their AI agent, the review takes days. By the time the policy doc is updated, the architecture has changed twice.
This session presents a policy-as-code approach to AI governance that gives GRC teams direct control over runtime enforcement without requiring engineering deployments. Using OPA/Rego as the policy engine, governance rules become version-controlled, testable, and hot-reloadable artifacts that enforce at the point of action rather than the point of review.
The talk walks through real implementation: writing Rego policies that map to NIST 800-53 controls, building a policy bundle pipeline so GRC pushes updates without deployments, and separating policy ownership from infrastructure ownership so security teams and engineering teams stop blocking each other.
Key Learnings
• Why document-based AI governance fails in fast-moving engineering organizations
• Implementing policy-as-code with OPA/Rego for AI agent runtime enforcement
• Mapping Rego policies to NIST 800-53 and ISO 27001 control families
• Building a GRC policy pipeline: version control, testing, hot-reload, and audit trails
• Organizational patterns for separating policy ownership from infrastructure deployment
From OWASP Theory to Enterprise Controls: Mapping the Agentic Top 10 to Deployable Controls.
The OWASP Top 10 for LLM Applications and the emerging Agentic Security risks have given the industry a shared vocabulary. But vocabulary doesn't ship security controls. Most organizations read the list, nod, and then have no idea what to deploy on Monday morning.
This session bridges the gap between OWASP's risk taxonomy and deployable enterprise security controls. For each major agentic risk , tool poisoning, excessive agency, confused deputy attacks, indirect prompt injection , the talk maps specific, implementable controls drawn from real enterprise deployments. Not theoretical mitigations. Actual architecture patterns, policy configurations, and detection rules.
The session includes a head-to-head security comparison of Claude Code vs. Cursor mapped against the OWASP Agentic Top 10, showing how different AI coding agent architectures create different attack surfaces and require different control strategies.
Key Learnings
• Translating OWASP Agentic Top 10 risks into specific, deployable enterprise security controls
• Architecture-level differences in AI coding agent security: Claude Code vs. Cursor attack surface comparison
• Implementing detection rules for tool poisoning and confused deputy attacks in production
• Building a threat model for multi-agent systems that goes beyond single-agent prompt injection
• A reusable mapping framework your team can apply to evaluate any AI agent deployment
Automating the 'Governance': Building a Rules Engine for AI Use Case Governance at Scale
Every enterprise deploying AI faces the same problem: hundreds of teams want to ship AI features, and security needs to evaluate each one. Manual review doesn't scale. Spreadsheet-based tracking breaks. And without clear automated rules, governance becomes either a rubber stamp or a permanent bottleneck.
This session presents a practical rules engine architecture for AI use case governance that evaluates deployment requests against policy rules defined in YAML, with short-circuit 'red zone' logic for automatic rejection of high-risk patterns and graduated approval workflows for everything else. The engine processes JSON context from intake forms, evaluates against tiered policy rules, and produces auditable approval or rejection decisions.
The talk covers the full system: rule definition, evaluation logic, red zone short-circuiting, general approval criteria, integration with existing GRC workflows, and lessons learned from operating the system across dozens of AI use case submissions.
Key Learnings
• Why manual AI use case governance fails at enterprise scale and what to automate first
• Designing a rules engine with YAML-defined policies and JSON context evaluation
• Red zone short-circuit logic: automatically rejecting high-risk AI patterns without human review
• Graduated approval workflows: tiered governance based on risk classification
• Integrating automated governance into existing security review and GRC workflows
OWASP LASCON 2026 Sessionize Event Upcoming
AI TechWorld 2026 Sessionize Event
Global Data & AI Virtual Tech Conference 2026 Sessionize Event
Aakash Abhay Yadav
Managing CyberSecurity GRC | OWASP AI Exchange Author
San Francisco, California, United States
Links
Actions
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top