Works With Everything You Already Use

LangChain

Middleware that wraps tool execution with permission checks and audit logging. Compatible with LangChain agents, chains, and tool classes.

OpenAI Assistants

Function call interceptor that verifies agent permissions before tool execution and logs results as audit events.

Claude (Anthropic)

Tool use interceptor that wraps Claude's tool calls with identity verification, permission enforcement, and automatic audit event emission.

Grok (xAI)

Grok uses the standard tool-calling format, so Vorim gates and signs each custom function tool call the same way it does for other model APIs. Point the client at api.x.ai, and every tool the agent runs is permission-checked and recorded as a signed audit event. Grok's built-in server-side tools execute inside xAI and aren't attestable. Grok Build (the coding CLI) also connects via the Vorim MCP server.

CrewAI

Task-level integration that maps crew member identities to Vorim agents and enforces per-task permission boundaries.

LlamaIndex

Query engine wrapper that logs data access patterns, enforces read/write permissions, and records retrieval audit trails.

Pydantic AI

Type-safe dependency injection with VorimDeps. Permission checking and audit logging via vorim_tool decorator. Full RunContext integration.

Vercel AI SDK

Wrap the tools you pass to generateText / streamText. wrapVercelTools gates each tool call with a permission or runtime-control check and records a signed audit event. Opt into runtime control to link every event to a decision_id.

LangGraph

Guard the tools inside your LangGraph nodes. wrapGraphTools enforces a permission or runtime-control check on every tool a node executes and records a signed audit event tagged to the graph. Drop the guarded tools into a ToolNode or prebuilt ReAct agent.

Microsoft AutoGen / AG2

Guard the functions your AutoGen agents call. The vorim_guard decorator gates each tool with a permission or runtime-control check and emits a signed audit event before registering it with your agent.

Google ADK

Guard the function tools in your Google Agent Development Kit agents. The vorim_tool decorator wraps the callable behind a FunctionTool with a permission or runtime-control check and a signed audit event.

Hermes Agent

Secure the Nous Research Hermes Agent. Connect Vorim's MCP server for the tool catalog, and wrap Hermes tools with the SDK (TS + Python) or the native plugin so every call is gated (allow / deny / escalate, fail-closed) and recorded as a signed audit event.

Cursor

Add the Vorim MCP server via .cursor/mcp.json, and Cursor reads AGENTS.md natively. Every agent you build in Cursor gets identity, scoped permissions, and signed audit.

GitHub Copilot

Add the Vorim MCP server to VS Code (.vscode/mcp.json, root key "servers"), or use a Copilot AGENTS.md. Agents built with Copilot get Vorim identity, permissions, and signed audit.

Claude Code

One command wires Vorim in. Your Claude agents get identity, permissions, and signed audit, and Vorim writes a CLAUDE.md so the assistant knows the conventions.

Devin

Devin reads AGENTS.md natively, and you can add the Vorim MCP server so every agent Devin builds gets identity, scoped permissions, and a signed audit trail.

Zed

Register the Vorim MCP server as a Zed context server; Zed also supports project and global AGENTS.md. Agents in Zed get identity, permissions, and signed audit.

JetBrains Junie

Add the Vorim MCP server via .junie/mcp/mcp.json, or point Junie's AGENTS.md at Vorim. Agents get identity, permissions, and signed audit inside your JetBrains IDE.

OpenAI Codex

One command adds Vorim to Codex, which reads AGENTS.md natively. Agents Codex runs get identity, permissions, and signed audit.

Gemini CLI

Add the Vorim MCP server to Gemini CLI's settings.json. Point its context file at AGENTS.md to share Vorim conventions. Agents get identity, permissions, and signed audit.

Continue

Add the Vorim MCP server to Continue's config.yaml in agent mode. Agents get identity, permissions, and signed audit.

Cline

Add the Vorim MCP server to Cline in VS Code. Every agent it builds gets identity, permissions, and signed audit.

Roo Code

Add the Vorim MCP server to Roo Code; it also supports AGENTS.md. Agents it builds get identity, permissions, and signed audit.

Warp

Add the Vorim MCP server to Warp, which also supports AGENTS.md. Agents Warp runs in your terminal get identity, permissions, and signed audit.

Google Antigravity

Add the Vorim MCP server to Antigravity via .agents/mcp_config.json (or the global ~/.gemini/config/mcp_config.json). Every agent it runs in the editor, terminal, or browser gets identity, scoped permissions, and a signed audit trail.

Google A2A Protocol

Extends A2A Agent Cards with cryptographic identity, live trust scoring (0-100), and permission verification. Verify incoming agents before interacting.

MCP (Model Context Protocol)

19 tools for Claude and any MCP-compatible client. Register agents, check permissions, emit audit events, verify trust, and manage credentials directly from Claude. Every tool is scope-gated by your API key, and actions are logged as audit events; sign them tamper-evident client-side with @vorim/sdk.

Web Bot Auth

Turn a Vorim agent identity into an RFC 9421 HTTP Message Signature (Signature-Input / Signature / Signature-Agent), so an agent proves who it is to any publisher on the agentic web instead of a spoofable User-Agent. Same Ed25519 identity carries a live trust score and a signed audit trail. Standalone signer, runs on Workers, browser, Deno, Bun, or Node.

TruAnon

Check that a real, anchored human stands behind an action before an agent proceeds. Verify a TruAnon human anchor (rank and score), require a minimum rank, then sign a single audit event capturing both the human and the agent identity. The private key stays server-side; Unknown never clears the bar.

Stripe Agentic Commerce (ACP)

Agent identity verification before payments. Ensures only authorized agents with transact permission can create checkouts via Stripe ACP. Full audit trail on every transaction.

Google UCP (Universal Commerce Protocol)

Verify an agent's identity, transact permission, and trust score before a UCP checkout, then sign every order as cryptographically verifiable evidence. The identity and audit layer for Google's open agentic-commerce protocol.

Shopify (store operations)

For an agent that manages a Shopify store through the Admin API. On the Admin API an agent authenticates with one OAuth token and coarse write scopes: every agent looks identical, and nothing proves which one issued a refund. Vorim checks the acting agent's permission before each mutation (create order, refund, adjust inventory, fulfil, return, edit product), caps a delegated agent's refunds below a ceiling that Shopify's write_orders scope cannot express, then signs a tamper-evident record of what it did. It composes with Web Bot Auth and Visa TAP on the buyer side rather than replacing them.

x402

Authorize an agent before it settles an open HTTP-402 payment, and sign the settle / fail lifecycle. For agents paying per-request for APIs, data, or compute.

Verify an agent before it presents an AP2 Checkout or Payment Mandate, and sign the mandate + receipt lifecycle, capturing the checkout hash so the two evidence trails reconcile. Google's open, FIDO-governed mandate standard.

PayPal Agent Toolkit

Verify an agent before it creates a PayPal order or captures a payment, and sign the order / capture / refund lifecycle. Sits in front of PayPal's Orders v2 agent toolkit.

Circle Agent Stack

Authorize an agent before it makes a Circle USDC payment, and sign the sent / failed lifecycle. Complements Circle's native spend caps with cross-provider identity and an independent signed audit trail.

Skyfire KYAPay

Verify an agent before it mints a Skyfire kya / pay / kya-pay token, and sign the token + charge lifecycle. Agent-to-agent payments with an independent audit trail.

Nekuda

Verify an agent before it creates a Nekuda purchase mandate, and sign the mandate + card-reveal lifecycle. Wraps the agent-wallet mandate step, before any card is revealed.

Authorize an agent before it initiates an ACH, wire, or RTP transfer via developer-bank APIs like Increase and Column, and sign the initiate / approve / settle lifecycle. Complements the bank's own approval controls.

Plaid Transfer (sandbox)

Authorize an agent before a Plaid ACH transfer and sign the decision / created / settled lifecycle. Sandbox-ready today; flips to production once your Plaid Transfer application is approved.

Modern Treasury (sandbox)

Authorize an agent before a Modern Treasury payment order and sign the order / approval / completion lifecycle. Sandbox-ready today; flips to production once your KYB onboarding completes.

Stripe Issuing (agent cards)

Issue an agent a virtual card with a Vorim-enforced spend limit, and sign every real-time authorization. Vorim decides the issuing_authorization.request webhook against the agent's delegated ceiling, escalates above it to a named approver, and signs a tamper-evident record of each approve or decline. The spend path fails closed.

Lithic (agent cards)

Card issuing with Auth Stream Access. Vorim makes the real-time ASA approve/decline against a per-transaction ceiling and signs it. SINGLE_USE and MERCHANT_LOCKED cards map cleanly to one-shot and merchant-pinned delegated spend.

Marqeta (agent cards)

Enterprise card issuing with Just-in-Time (JIT) Funding. Vorim decides the JIT gateway call in real time against the agent's spend ceiling, escalates above it to a named approver, and signs every funding decision. The enterprise-issuer version of the same signed-authorization story.

Coinbase CDP Wallet

Guard an agent's onchain wallet. Distinct from x402: this sits in front of the wallet that signs and broadcasts. Vorim enforces a per-transaction value ceiling, a network allowlist, and a destination-address allowlist before each broadcast, escalates above the ceiling to a named approver, and signs an attributable record of every transaction.

Ramp (agent spend cards)

Governed B2B provisioning of Ramp virtual spend cards. Vorim caps the limit an agent may create or raise and signs each card-issue and limit-change. Ramp has no real-time authorization webhook, so the signed record sits at provisioning; use the issuer connectors when you need a signed record of every authorization.

Guidewire (insurance core)

For an AI adjuster acting on Guidewire ClaimCenter / PolicyCenter. Dollar-ceiling attenuation is the fit: an agent may pay claims and set reserves up to a signed limit; above it, the check-set or reserve-set auto-escalates to a named human adjuster. Every decision is signed as evidence for the documented, attributable, auditable AI-decision obligations under the NAIC Model Bulletin.

Benchling & Veeva Vault (life sciences)

For an agent acting on a validated GxP system of record. The agent may draft and write, but releasing a result or moving a document to an approved lifecycle state escalates to the human of record, whose signature carries the FDA 21 CFR Part 11 §11.50 manifestation elements: signer, timestamp, and meaning. An independent, tamper-evident record beside the system's own Part 11 controls.

HL7 FHIR (healthcare)

For an agent writing to an EHR through the vendor-neutral HL7 FHIR R4 API over SMART on FHIR (the surface Epic, Oracle Health, and any certified server share). Read-only and resource-type caps enforce least privilege; a prescription or lab order (MedicationRequest / ServiceRequest) is forced to an unsigned draft that escalates to a clinician to sign. Supports HIPAA §164.312 audit controls and integrity. Carries no PHI in the signed record.

iManage & NetDocuments (legal)

For an agent acting on a legal document management system. The monotonic access rule is the wedge: an agent may narrow document access but never widen it, alter a privilege designation, share externally, or produce in discovery without the supervising lawyer's approval. Every action is signed as defensible evidence of attribution and supervision under ABA Formal Opinion 512 and e-discovery chain of custody.

Cloudflare Browser Run

Cloudflare's agent-first browser (kitesurf) makes agents cheap to run on the edge. Vorim adds the trust layer in the same path: a Worker guard checks the acting agent's permission before each browsing action, then signs a receipt naming the agent and the human it acts for, verifiable offline with no call back to Vorim or Cloudflare. It runs natively on Workers (Web Crypto Ed25519, no Node).

OpenClaw

Give your OpenClaw agent a cryptographic identity, enforce permissions before sensitive actions, and log a tamper-proof audit trail. Installs as a skill via mcporter + MCP server.

Block Buzz

Mirror Block's Buzz (the Nostr workspace for humans and agents) into a Vorim audit trail. The bridge verifies each Buzz event's secp256k1 / Schnorr signature and roster membership, then re-signs the record with Vorim's Ed25519 key — two independently verifiable chains, cross-linked by event id.

Fully typed client for all platform capabilities. Agent registration, permission management, audit events, trust verification, credential delegation, and ephemeral identity.

Synchronous and asynchronous clients with full feature parity. Uses httpx for non-blocking operations in async agent frameworks.

Query any agent's trust score, status, and public key fingerprint. Rate-limited for fair use. Returns trust breakdown by factor.

Embeddable SVG badge displaying an agent's trust score. Use in dashboards, documentation, agent directories, and marketplaces.

SIEM (Splunk / Elastic / OTel)

Forward the signed audit trail into your SIEM. createSiemForwarder maps each audit event to an OpenTelemetry log record and ships it to an OTLP collector, Splunk HEC, or Elasticsearch, so agent actions land in the tools your security team already watches.

Slack

Install the Vorim Slack app to check agents from where your team already works: /vorim verify <agent> returns an agent's trust score and status, /vorim agents lists your organisation's agents. Runtime escalations and auth alerts can post to Slack too.

n8n

Community node (n8n-nodes-vorim) with Check Permission, Runtime Decision, Emit Audit Event, Verify Trust, and Register Agent operations. Self-hostable, for the automation platform enterprises run themselves.

Zapier

Zapier app with actions (check permission, runtime decision, emit audit event, verify trust) and a New Audit Event trigger. Wire Vorim into thousands of apps with no code.

Make

Make (Integromat) custom app with permission, runtime-decision, audit, and trust modules. Drop Vorim into your Make scenarios.

Okta (Management API)

For an agent that administers an Okta org. An Okta SSWS token is unscoped: it inherits the full permissions of the admin who created it, and nothing proves which agent made a given change. Vorim binds each Management API write to a verified agent identity, caps what a delegated agent may do, and forces a named human admin into the loop for the two highest-stakes ops, granting an admin role and minting an API token. Every change is signed. Guards the stable Okta Management API; not the sales-gated Okta for AI Agents product.

Microsoft Entra ID

For an agent that administers Entra ID through Microsoft Graph v1.0. Vorim gates and signs each directory write and always escalates the three ops that grant standing, tenant-wide authority to a named admin: assigning a directory role, adding a client secret to an app, and granting a tenant-wide app-role assignment. Guards the stable Graph v1.0 admin surface; not the Entra Agent ID beta API, which Microsoft marks not-for-production.

AWS IAM / STS

For an agent that manages AWS identity through IAM and STS. CreateAccessKey mints a long-lived static credential, the single highest-stakes IAM op, so it always escalates to a named admin, alongside the privilege-escalation ops (CreateRole, AttachRolePolicy, PutRolePolicy). Short-lived AssumeRole passes with lighter friction. Every change is signed. Guards the stable, free-to-use IAM/STS surface; a Bedrock AgentCore connector can follow.