agentpass-identity 0.1.0

AgentPass Python SDK for identity and access management

AgentPass Python SDK

Enterprise-Grade Identity & Access Management for AI Agents

Secure your AI agents with JWT authentication, RBAC/ABAC policies, risk assessment, and comprehensive audit logging.

📚 Documentation | 🚀 Quick Start | 💬 Discussions | 🐛 Issue Tracker

---

What is AgentPass?

AgentPass is a Python SDK designed specifically for securing AI agent applications. It provides a unified security layer with:

• JWT-based Authentication - Secure token issuance and validation
• Fine-grained Authorization - RBAC and ABAC policy engines
• Real-time Risk Assessment - Anomaly and fraud detection
• Comprehensive Audit Logging - Complete visibility into agent activities
• FastAPI Integration - Drop-in middleware for web applications
• YAML Policy Management - Human-readable security policies

┌─────────────────────────────────────────────────────────────┐
│                    Your AI Application                       │
├─────────────────────────────────────────────────────────────┤
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐   │
│  │   Agent A   │    │   Agent B   │    │   Agent C   │   │
│  └──────┬──────┘    └──────┬──────┘    └──────┬──────┘   │
│         │                   │                   │          │
│         └───────────────────┼───────────────────┘          │
│                             │                              │
│                    ┌────────▼────────┐                    │
│                    │   AgentPass    │                     │
│                    │      SDK        │                     │
│                    ├─────────────────┤                    │
│                    │  Auth (JWT)     │                     │
│                    │  Policy (RBAC)  │                     │
│                    │  Risk Engine   │                     │
│                    │  Audit Logger  │                     │
│                    └────────┬────────┘                    │
│                             │                              │
└─────────────────────────────┼───────────────────────────────┘
                              │
                    ┌─────────▼─────────┐
                    │   Protected        │
                    │   Resources        │
                    └────────────────────┘

Why AgentPass?

As AI agents become more prevalent, security becomes critical:

Challenge	AgentPass Solution
Token theft & spoofing	JWT with signature verification
Unauthorized resource access	RBAC + ABAC policy engine
Malicious prompt injection	Risk assessment with anomaly detection
Compliance & audit requirements	Complete audit trail with export
Complex permission management	YAML-based policy definitions

Quick Start

Installation

pip install agentpass

For FastAPI integration:

pip install "agentpass[fastapi]"

Minimal Example

from agentpass import Guard

# Initialize Guard with your secret
guard = Guard(secret="your-secure-secret-key")

# Issue a token for an agent
token = guard.issue_token("agent_001", role="admin")

# Check permissions
result = guard.check(
    token=token,
    action="read_doc",
    resource="internal_doc"
)

print(result)
# {
#     "allowed": True,
#     "reason": "Access granted",
#     "risk_level": "low",
#     "risk_score": 0.0,
#     "agent_id": "agent_001",
#     "role": "admin"
# }

Advanced Usage with Policies

from agentpass import Guard, Policy, PolicyRule, Priority

guard = Guard(secret="your-secure-secret-key")

# Add custom policy
guard.add_policy(Policy(
    id="secure_zone",
    name="Secure Zone Policy",
    priority_strategy=Priority.DENY_OVERRIDE,
    rules=[
        PolicyRule(
            resource="sensitive/*",
            action="*",
            effect="deny",
            priority=100,
            conditions={"role": {"require": ["admin"]}}
        ),
        PolicyRule(
            resource="sensitive/*",
            action="read",
            effect="allow",
            priority=50,
            conditions={
                "ip": {"allow": "private"},
                "time": {"hours": "9-18"}
            }
        )
    ]
))

# Risk-aware access decision
decision = guard.assess_and_protect(
    user_id="agent_001",
    resource="sensitive/data",
    action="read",
    context={"ip_address": "192.168.1.100"}
)

print(f"Decision: {decision['decision']}")  # allow or block
print(f"Risk Level: {decision['risk_assessment']['risk_level']}")

Core Features

🔐 JWT Authentication

• Secure token generation with configurable expiration
• Token validation with automatic refresh support
• Support for custom claims and metadata

🛡️ Policy Engine (RBAC/ABAC)

• Priority-based rule evaluation
• Multiple condition types: IP, time, role, resource tags
• YAML import/export for policy management
• Explainable decision paths

# Priority-based evaluation
policy = Policy(
    id="access_control",
    priority_strategy=Priority.DENY_OVERRIDE,
    rules=[
        PolicyRule(resource="admin:*", action="*", effect="allow", priority=100),
        PolicyRule(resource="doc:*", action="read", effect="allow", priority=50),
        PolicyRule(resource="*", action="*", effect="deny", priority=0),
    ]
)

🎯 Risk Engine

• Pluggable detector architecture
• Anomaly detection
• Fraud detection
• Configurable risk thresholds

📝 Audit Logging

• Structured event logging
• JSON/CSV export
• Integration with existing databases

from agentpass import Audit, AuditEvent

audit = Audit(storage_backend=None)

audit.log_event(AuditEvent(
    event_type="access_attempt",
    user_id="agent_001",
    resource="doc:confidential",
    action="read",
    status="deny"
))

# Export audit trail
json_output = audit.export_to_json()
csv_output = audit.export_to_csv()

FastAPI Integration

from fastapi import FastAPI
from agentpass import GuardMiddleware

app = FastAPI()

app.add_middleware(
    GuardMiddleware,
    secret="your-secret",
    exclude_paths=["/health", "/login"]
)

@app.get("/profile")
async def get_profile(request: Request):
    # request.state.user contains the authenticated agent info
    user = request.state.user
    return {"agent_id": user["sub"], "role": user["role"]}

Project Structure

agentpass-sdk/
├── pyproject.toml              # Package configuration
├── README.md                   # This file
├── LICENSE                     # MIT License
├── src/
│   └── agentpass/             # SDK source code
│       ├── __init__.py         # Package exports
│       ├── auth.py             # JWT authentication
│       ├── policy.py           # Policy engine
│       ├── audit.py             # Audit logging
│       ├── detector.py         # Risk detectors
│       ├── risk.py             # Risk assessment
│       ├── guard.py            # Unified facade
│       └── integrations/        # Framework integrations
│           └── fastapi.py       # FastAPI middleware
├── tests/
│   ├── test_demo.py            # Basic demo tests
│   ├── test_sdk_verification.py  # SDK verification
│   ├── test_api_verification.py  # API tests
│   └── test_permissions_audit.py # Permission tests
└── examples/
    └── app.py                  # FastAPI demo application

Testing

Run the complete test suite:

cd agentpass-sdk
python tests/test_sdk_verification.py

Test results: 24/24 passing (100%)

============================================================
Test Results: 24/24 Passing (100.0%)
============================================================

[1. SDK Installation Verification]
  [PASS] from agentpass import Guard
  [PASS] Version check
  [PASS] Policy module import
  [PASS] Audit module import
  [PASS] Risk module import
  [PASS] FastAPI integration import
  [PASS] Dependency check

[2. Guard API Verification]
  [PASS] Guard initialization
  [PASS] Token issuance
  [PASS] Token verification
  [PASS] Permission check - allow
  [PASS] Permission check - deny
  [PASS] assess_and_protect

[3. Policy Module Verification]
  [PASS] Policy creation
  [PASS] DENY_OVERRIDE strategy
  [PASS] ALLOW_OVERRIDE strategy
  [PASS] IP condition matching
  [PASS] Role condition matching
  [PASS] explain() method
  [PASS] YAML export
  [PASS] YAML import

[4. Audit Module Verification]
  [PASS] Audit initialization
  [PASS] Event recording
  [PASS] Event query

Roadmap

v0.1.0 (Current)

• JWT authentication
• RBAC policy engine
• Basic audit logging
• Simple risk assessment
• FastAPI middleware
• YAML policy support

v0.2.0 (Planned)

• ABAC attribute-based access control
• Pluggable detector plugins
• Advanced risk scoring algorithms
• Persistent audit storage backends
• Prompt injection detection

v1.0.0 (Future)

• Production stability guarantee
• Complete API documentation
• Enterprise security audit
• Official plugin ecosystem
• Long-term support commitment

Integration with Existing Systems

AgentPass is designed for gradual adoption. The SDK can be integrated alongside existing security infrastructure:

# Existing system continues to work
from app.adapters import get_adapter

# AgentPass provides additional security layer
agentpass = get_adapter(settings.JWT_SECRET)

# Existing policy remains primary decision maker
# AgentPass provides risk assessment and audit

Contributing

Contributions are welcome! Please see CONTRIBUTING.md for guidelines.

License

This project is licensed under the MIT License.

---

Built with security in mind for the AI agent era
_{© 2026 AgentPass Team}