AI guardrails & agent security
3,625 agents · most starred first
AI guardrails & agent security, page 29 of 37
AI Agent Security Scanner — detect prompt injection, tool auth bypass, data leaks
PermAegis × CrewAI — a Task guardrail that verifies a task's output HONORS the declared want (the Zoe commit|refund seam), returning CrewAI's [valid, feedback] tuple.
PermAegis agent-harness core — the two universal seams (OCap gate + Zoe verify) + Merkle receipt verifier, as a zero-dependency TypeScript client (native fetch + node:crypto).
Anthropic tool_use governance middleware for Aegis ACP
LangChain governance middleware for Aegis ACP (maintenance-only — Anthropic SDK is the active hero)
OpenAI tool_calls governance middleware for Aegis ACP (maintenance-only — Anthropic SDK is the active hero)
Defensive package-name reservation notice for a potential supply-chain risk.
Reserved for Garrison, Agile Defense's secure agentic AI platform. Placeholder release.
Reserved for Garrison, Agile Defense's secure agentic AI platform. Placeholder release.
Vaultak runtime security components for Haystack pipelines
IRIS governance for CrewAI crews — Cedar policy on every agent tool call
IRIS governance for LangChain agents — Cedar policy on every tool call
Security scanner for MCP (Model Context Protocol) server configurations and AI agent tool permissions.
Defensive package-name reservation notice for a potential supply-chain risk.
OpenAI SDK with OmegaEngine governance - AI safety and compliance
Client signing surface for federated AI-agent chapters — identity, canonical strings, Ed25519 signatures, headers.
Lightweight identity, auth, and audit layer for AI agent SDKs (OpenAI, Anthropic)
Driver to connect to Open Policy Agent (OPA) and EOPA deployments.
LLM Guard Rails - An actively maintained security toolkit for Large Language Model interactions. Features advanced sanitization, harmful language detection, data leakage prevention, and prompt injection resistance with continuous improvements and enhancements.
Free MCP security scanner — finds risks in your AI agent setup
Security scanner for PostHog's agentic flows
Sanctum Runtime SDK — the runtime trust boundary for autonomous systems. Signed action tokens, blast-radius scoring, source-trust classification (indirect-prompt-injection defense), dual-approver + auto-escalate, policy replay, SOC2 + NIST AI RMF evidence
<p align="center"> <img src="https://raw.githubusercontent.com/cacheplane/dawnai/main/docs/brand/dawn-logo-horizontal-black-on-white.png" alt="Dawn" width="180" /> </p>
Runtime guardrails for TypeScript AI agents — prevents duplicate tool calls, enforces per-user LLM cost budgets, and gates irreversible actions before they execute. Works with Mastra, Vercel AI SDK, LangGraph.js, and OpenAI Agents SDK.
AWS Bedrock Agents governance middleware for Aegis ACP (maintenance-only — Anthropic SDK is the active hero)
Runtime policy control plane for production AI agents. Block, degrade, escalate — without a redeploy.
Standalone security daemon for IDE-agnostic AI agent security
Nuggets authority middleware for LangChain.js / LangGraph.js
Prevents untrusted data from triggering consequential actions in your agent.
Production-grade safety guardrails for LLM agents — injection detection, PII redaction, tool governance
ESLint for your LLM prompts — catch prompt-injection risks, missing token limits, and prompt anti-patterns before you ship.
Client SDK for the Agent Auth Protocol — agent identity, registration, and capability-based authorization
Framework-agnostic vault-entry-as-tool resolver for deny.sh. The shared security core behind every deny.sh agent-framework adapter.
OpenClaw plugin for Radware Agentic Protection
Aegis policy pack: LLM Guard scanners (prompt injection, toxicity, secrets).
AgentTrust Edge — Full Governance Platform. Policy Engine + MAD Classifier + HITL + Kill Switch.
AgentSec-Bench: a security benchmark for LLM agents and harnesses, built on Inspect AI
A lightweight toolkit for building secure AI systems with built-in middleware, protected memory, and AI safety models that mitigate prompt injection, jailbreaks, and adversarial attacks.
IBBS review: compare features, pricing, use cases, access model, and alternatives for this AI Security agent in 2026. A security badge proving your AI agent resists prompt injection attacks.
Runtime authorization guard for AI agent tool calls.
Tripwire security for LLM agent pipelines — honeytokens that fire when an agent acts on an injected instruction. v0.1 coming soon.
Give your AI agent a signed, verifiable identity in one line.
LangChain tools for Bolyra mutual ZKP authentication and SD-JWT delegation
Agent-first guardrails framework for AI-assisted Python projects
LLM security middleware and risk analysis layer for prompt injection detection
SecureVector SDK for LangChain — brings the local threat monitor's three controls (tool-call permissions, secret/data-leak detection, threat detection) to every LangChain tool call, with tamper-evident audit logging.
The language-agnostic governance-gate sidecar — govern a non-MCP agent runtime (LangGraph, CrewAI, AutoGen) by remoting each native tool call through the Action Kernel over a thin NDJSON-RPC seam. The reusable spine of Lodestar's runtime-adapter epic.
OpenAI Agents SDK adapter for Bolyra -- guardrails, tool wrappers, and MCP auth
Govern an AutoGen agent's native tool calls with Lodestar — the thin native hook that remotes each tool call through the Lodestar Action Kernel over NDJSON-RPC (ADR-0027).
Govern a CrewAI crew's native tool calls with Lodestar — the thin native hook that remotes each tool call through the Lodestar Action Kernel over NDJSON-RPC (ADR-0026).
Govern a LangGraph agent's native tool calls with Lodestar — the thin native hook that remotes each tool call through the Lodestar Action Kernel over NDJSON-RPC (ADR-0024).
AI agent security & MCP security middleware — prompt injection detection, AI firewall, runtime guardrails & data-loss prevention for LLM tool calls. 8-layer defense against data exfiltration & dangerous commands. Zero dependencies. SDK + OpenClaw plugin.
Least-privilege permissions for AI agents and MCP tools. Record what your agent does, auto-generate a safe policy, and block dangerous tool calls before they happen.
AgentShield SDK — instrument AI agents and capture execution events for the AgentShield Runtime Control Plane
Autonomous security scanner for AI agents. Detects prompt injection, tool abuse, data exfiltration, and OWASP ASI Top 10 vulnerabilities.
SecureVector SDK for CrewAI — brings the local threat monitor's three controls (tool-call permissions, secret/data-leak detection, threat detection) to every CrewAI tool call, with tamper-evident audit logging.
SecureVector SDK for LangGraph — brings the local threat monitor's three controls (tool-call permissions, secret/data-leak detection, threat detection) to every LangGraph tool call, with tamper-evident audit logging.
Interpreter for using ucast conditions with Prisma.
Runtime AI agent security SDK for MastGuard — prompt injection detection, scope enforcement, tamper-evident audit logging, and policy-based guardrails.
Pluggable multi-layer LLM jailbreak defense pipeline
AgentAuth — attested identity and verifiable execution receipts for autonomous AI agents
Open, content-addressed agent identity references bound into the pinned AlgoVoi substrate (agent_id + issuer + scope + validity window; L1 frozen)
npm audit for your AI agent's extensions: inventory installed MCP servers/skills and flag known-vulnerable (OSV), abandoned, and unpinned ones in CI.
Wrap AI agent tool functions with dry-run preview and user confirmation before execution
Credential primitives for the P3 Agentic Registry — types, canonicalization, hashing, and validation
Idiomatic, zero-dependency, provider-agnostic Python safety layer for AI agents: least-privilege permissions, prompt/input/output guards, sandbox + SSRF guards, quotas/rate/deadline/concurrency/risk budgets, loop detection, human-in-the-loop approval, constitutional rules, action previews, honeytokens, audit/tracing, and Claude/OpenAI/Gemini/MCP tool-call integration.
Inline circuit breaker for LLM agents to prevent stuck loops, budget overruns, and output bloat.
A permission gate for AI agent tool calls. Stops dangerous actions before they execute. Safe under many concurrent agents.
Permission policy mediator for Claude Code, Codex, OpenCode, Gemini CLI, and Kiro.
Audit MCP server configurations for security risks
Non-blocking AI agent event logging for compliance teams
Sign and verify prompt templates and tool definitions for AI agent security
AI Agent data collection & security analysis gateway (TypeScript)
MCP security trust-check server for autonomous agents: safe install decisions, risk signals, controls and alternatives before installing MCPs, Skills or tools.
The model-independent trust layer for AI agents: verifiable identity, model provenance, tamper-evident SHA-256 audit chains, policy enforcement, and outcome verification. Framework-agnostic.
Node.js SDK for the BEACON Protocol - Agent Safety Layer
Tamper-evident audit trail for AI agents — EU AI Act ready
Governance spine for AgentForge — identity (feat-029) and, as they land, registry / policy / audit drivers
Vendor-neutral event logging and redaction for AI agent workflows
A guard-railed harness that keeps wild agents in check - one gate, sandboxed, reversible context.
AI Agent Runtime Security Platform — runtime security and behavioral monitoring for agentic AI systems
Defensive overlay for AI agents — 8-layer architecture with harness-agnostic adapters; ships 6 of 8 layers (1 skill_vetting, 2 sanitize, 3 structured_output, 4 bash_guard+write_guard, 6 audit, 7 config) plus adapters for Claude Code (PreToolUse) and OpenClaw (before_tool_call)
Open mission-assurance commons for secure, authorized, and reviewable AI agents.
Runtime semantic security layer for LLM-powered applications. The WAF for the AI era.
Deterministic security middleware for RAG applications to prevent context exfiltration via indirect prompt injection.
Detect and rebut rationalization patterns in AI agent output
Governance, proof, and intelligence controls for AI agent fleets.
Local-first, AI-agent-safe developer secrets manager (CLI).
The official JS/TS SDK for Creduent: the open standard and security protocol for cryptographic AI agent identity, authentication, and trust verification using Ed25519 and DNS.
LangChain integration for the Grantex delegated authorization protocol
Human-in-the-loop MCP server for AI agents — biometric approval with PKI-signed attestation. stdio + HTTP.
Lint OpenAPI specs for AI agent safety — detect risky operations, missing guards, destructive endpoints, and schema issues before exposing APIs to LLMs and agents
Core SDK for the Agentic Control Plane — govern any tool call from any agent framework. Delegation chain, scope intersection, budget propagation, audit log.
Wire ANY AI into STOA in one line. Wrap a tool/function so it is gated (prove-or-permit before it runs), permit-carrying, and receipted automatically — against the open STOA API, verifiable by anyone. From Vext Labs.
HelixID middleware for LangChain and LangGraph — verifiable credential enforcement at agent execution boundaries with per-tool scope checking.
A quarantine line for the data your LLM agent ingests: scan untrusted text and outbound actions for prompt injection and exfiltration.
Provider-agnostic action defender SDK for AI agents
Agent-hook safety gate for AI-written code -- blocks bidi/invisible Unicode and CJK corruption at the write boundary
Runtime security firewall for LLM agents — four-checkpoint scan engine, local-first with an optional hosted cloud tier
Verifier for AgentOracle composed envelopes (RFC 8785 JCS + Ed25519). Canonicalization is byte-identical to the production Node canonicalizer.