Zero-Trust Gateway Integration

Connecting Autonomous AI Agents to SentinelOps

Intercept every consequential mutation before it touches production. Integrate real-time sub-20ms policy enforcement, multi-party human approval quorums, and cryptographic audit logging into your Python, Node.js, and REST-based agent fleet.

Issue Agent Credential

Generate a scoped Agent API Key (`sop_live_...`) with least-privilege team boundaries from your SentinelOps credentials vault.

Evaluate Sub-20ms Policies

Wrap actions with `@sentinel.guard` or call `/api/v1/actions/evaluate` prior to calling APIs, executing SQL, or modifying resources.

Human-in-the-Loop & Audit

High-risk mutations trigger approval queues for authorized reviewers. All execution outcomes are sealed in a SHA-256 hash chain.

Quick Integration Snippets

1. Install the Python SDK

pip install sentinelops-ai

2. Evaluate, Poll & Report Outcome Pattern

from sentinelops import SentinelOps

# 1. Initialize client with your Agent API Key
sentinel = SentinelOps(
    api_key="sop_live_your_agent_key_here",
    base_url="https://sentinelops.dev"  # or http://localhost:3000 for local dev
)

# 2. Evaluate policy before executing any consequential action
decision = sentinel.evaluate(
    agent_id="sales-rep-01",
    agent_name="Enterprise Sales Agent",
    action="salesforce.account.update",
    resource="accounts/0015000000XyZ12",
    environment="production",
    context={
        "field": "annual_contract_value",
        "old_val": 45000,
        "new_val": 120000,
        "discount_percent": 25
    }
)

# 3. Handle sub-20ms policy engine decision
if decision.approved:
    # Action complies with active policies
    print("Action allowed by Zero-Trust policy engine.")
    # execute_mutation(...)
    
    # 4. Report outcome telemetry for the cryptographic audit trail
    sentinel.report_outcome(
        decision.request_id,
        status="succeeded",
        summary="Updated ARR on Salesforce account 0015000000XyZ12"
    )

elif decision.pending:
    # Consequential action intercepted! Awaiting human sign-off.
    print(f"Action routed for human review. Request ID: {decision.request_id}")
    
    # Poll until authorized operator approves or denies
    resolved_decision = sentinel.poll(decision.request_id, timeout_seconds=300)
    
    if resolved_decision.approved:
        # Operator approved in dashboard
        # execute_mutation(...)
        sentinel.report_outcome(
            decision.request_id,
            status="succeeded",
            summary="Executed after operator approval"
        )
    else:
        print(f"Operator denied action: {resolved_decision.reason}")

else:
    # Blocked immediately by automated guardrail policy
    print(f"Action blocked by policy: {decision.reason}")

3. Decorator Pattern (@sentinel.guard)

from sentinelops import SentinelOps

sentinel = SentinelOps(api_key="sop_live_your_agent_key_here")

# Wrap your agent tool / function directly with the @guard decorator
@sentinel.guard(
    agent_id="sales-rep-01",
    agent_name="Enterprise Sales Agent",
    action="slack.channel.broadcast"
)
def broadcast_deal_close(customer_name: str, deal_size_usd: float):
    """Executes only when evaluated and approved by SentinelOps."""
    slack_client.chat_postMessage(
        channel="#sales-wins",
        text=f"Closed {customer_name} for ${deal_size_usd:,.2f}!"
    )
    return {"status": "broadcasted"}

# Calling this automatically performs evaluate -> poll -> execute -> report_outcome
broadcast_deal_close(customer_name="Acme Corp", deal_size_usd=120000)

Popular Framework Integration Patterns

SentinelOps seamlessly wraps tools and actions in LangChain, LlamaIndex, CrewAI, and AutoGen.

LangChain Tool Wrapper

Intercept LangChain `@tool` or `BaseTool` instances by evaluating arguments through SentinelOps before running the function.

from langchain.tools import tool

@tool
def execute_sql_query(query: str) -> str:
    """Executes SQL against analytical warehouse."""
    decision = sentinel.evaluate(
        agent_id="langchain-analyst",
        action="database.sql.query",
        resource="postgres/analytics",
        context={"query": query}
    )
    if not decision.approved:
        return f"Query rejected: {decision.reason}"
    return db.execute(query)

CrewAI Task Guardrail

Equip CrewAI agent tools with dual-custody verification for high-impact outputs (e.g. drafting emails, executing payments).

from crewai.tools import tool

@tool("Send Invoice")
def send_invoice(client_id: str, amount: float) -> str:
    """Sends financial invoice to external client."""
    decision = sentinel.evaluate(
        agent_id="finance-crew-billing",
        action="billing.invoice.send",
        resource=f"clients/{client_id}",
        context={"amount": amount}
    )
    if decision.approved:
        return stripe.Invoice.create(...)
    return "Action queued for human approval"

Zero-Trust Architectural Guarantees

Sub-20ms SLAIn-memory state and optimized monotonic indexing guarantee policy evaluation completes in under 20 milliseconds without adding latency to agent workflows.

Transitive Four-EyesMakers cannot review their own requests. Out-of-Office (OOO) and delegator sign-off preserves non-repudiation and SOX/SOC-2 compliance.

HMAC-SHA-256 SealEvery policy check, human approval, and reported outcome receives a cryptographically linked hash seal that prevents log tampering or deletion.

Ready to protect your agent fleet?

Create API Key Register Agent