RailGuard logo

RailGuard

Security

Spend control & audit

Governance for the money your AI agents spend

Give every agent a budget, a policy set and a paper trail. Approve what matters, block what doesn't, and answer “why did this payment go through?” months later.

No sign-up, no card. Send a test purchase and watch it get approved, held or blocked.

Built for teams running CrewAI / LangChain agents in production · Try the 60-second demo →

Live policy evaluation
STREAMING
Agent: invoice-processor$45.00 → APPROVED
Agent: research-bot$128.40 → APPROVED
Agent: ad-buyer$640.00 → FLAGGED
Agent: procurement-01$1,900.00 → BLOCKED
Agent: invoice-processor$12.10 → APPROVED
$12.4k
Governed agent spend in the demo workspace this month

See it in action

From spend request to audit trail

Open interactive demo

Recorded from the public sample workspace. No real payment is made. If the recording won't load, open the interactive demo.

One transaction, end to end

An illustrative $250 request: policy hit → human approval → audit row, followed by a changed-amount request.

  1. Request

    POST /api/public/transactions14:02:07.112 UTC

    research-agent-02 asks to pay $250.00 to OpenAI API — “Batch-embed 12k support tickets for the weekly churn report.”

  2. Policy hit

    FLAGGED14:02:07.131 UTC

    Monthly budget: $1,840 / $5,000 → pass. Merchant allowlist: OpenAI → pass. Auto-approve cap: $250 > $100 → requires approval.

  3. Approval

    APPROVED14:06:41.508 UTC

    Priya S. (Approver) approves from Slack: “Expected — quarterly re-index.” Single-use card issued to the agent.

  4. Audit row

    APPEND-ONLY14:06:41.522 UTC
    audit_log  #48213
    action     transaction.approved
    actor      priya@acme.com (approver)
    agent      research-agent-02
    amount     250.00 USD → OpenAI API
    reason     auto_approve_cap exceeded (250 > 100);
               approved: "Expected — quarterly re-index."
    UPDATE / DELETE → denied by database policy
  5. Second request: amount changed

    NEW EVALUATION14:07:03.104 UTC

    The agent now asks for $300.00 to OpenAI API. The old $250 approval is invalid for this changed request: it cannot authorize $300. The new request needs its own policy check and human decision. The original card remains separately usable until cancelled.

Product comparison

Ramp, Stripe and RailGuard: where each fits

Ramp manages company spend, Stripe powers payments, and RailGuard focuses on the policies, human decisions and audit trail around an agent's spend. These tools can work together.

Finance platform + agent cards

Ramp

A broader spend management platform with funds, spend programs, approvals and agent card workflows.

  • Budget and merchant-category controls
  • Approval paths for spend requests
  • Agent cards through Ramp's agent tools

Product sources: Spend controls · Agent cards

Payment infrastructure

Stripe

Issuing controls for cards alongside tools for agentic commerce and machine-to-machine payments.

  • Issuing limits and merchant-category rules
  • Scoped payment credentials for agents
  • Payment and card infrastructure

Product sources: Issuing controls · Agent payments

Agent spend governance

RailGuard

A policy and audit layer for your existing agents, before and after their payment attempts.

  • Per-agent policies with reasoning context
  • Flagged requests routed to human review
  • Decision reasons, receipts and audit history in one place
See it in the public demo

Based on the linked product documentation; a comparison of focus, not an exhaustive feature checklist. Availability varies by plan, region and configuration. RailGuard is independent of Ramp and Stripe.

From agent decision to audit trail

01

Wrap your agent

Two lines of Python or TypeScript. guardrail.spend() intercepts every purchase attempt with the agent's reasoning attached.

02

Policies decide in real time

Budgets, merchant rules and thresholds are evaluated together. Approved spends execute; blocked ones return a reason to the agent.

03

Humans handle the edge cases

Out-of-policy spends pause and notify approvers. Every outcome lands in an immutable audit log you can export anytime.

Built for engineers

Wrap any spending function — CrewAI, LangChain or custom. The SDK sends amount, merchant and the agent's reasoning to RailGuard, and only executes when policy says yes.

  • Python & TypeScript SDKs
  • Per-agent API keys with rate limiting
  • Receipts reconciled against settled spend
from guardrail import Guardrail

guard = Guardrail(api_key="rg_...", base_url="https://railguardsecurity.com")

guard.spend(
    amount=45.00,
    merchant="OpenAI API",
    reasoning="Process 500 PDF invoices",
    idempotency_key="invoice-batch-0412",
)

Everything that ships today

Policy engine

Per-transaction caps, rolling budgets, merchant allow/blocklists and time windows — evaluated together, with a written reason for every decision.

Human approvals

Anything above your threshold pauses for a named reviewer, with Slack or Teams alerts and an AI-generated review summary.

Append-only audit

Every evaluation, approval and control change is written once and cannot be edited or deleted — enforced in the database, not the interface.

Agent API keys

Each agent gets its own credential with rate limiting, so the audit trail always knows exactly which agent submitted which payment.

Payment verification

Agents report receipts; RailGuard reconciles approved amounts against what actually settled and flags mismatches.

Slack & Teams alerts

Each workspace connects its own incoming webhook — approvers get pinged the moment a transaction needs a human decision.

Why AI agent spend needs its own governance layer

AI agents are moving from answering questions to taking actions — buying API credits, paying invoices, ordering supplies. Corporate cards and expense tools were built for humans who click “pay” a few times a day. An agent can attempt hundreds of purchases an hour, each one a real charge if nothing stands in the way.

RailGuard sits between the agent and the money. Every spending attempt is evaluated against the budgets, merchant rules and approval thresholds you set — before the payment executes, not in a report afterwards. In-policy spends go through automatically; anything unusual pauses for a named human approver with the agent's reasoning attached.

Every decision is written to an append-only audit trail enforced at the database level, so when finance or compliance asks “why did this payment go through?” months later, the answer is a record — not a guess. Read the agentic AI governance guide for the full framework.

Start free, scale with your agents

Every plan includes the policy engine, immutable audit log and Demo workspace. 14-day money-back guarantee on paid plans.

Developer

$0

Check out our demo first — pay later

  • 1,000 evaluations / month
  • 1 active agent
  • $500 / month governed spend
  • Python & Node SDK
Start free
Popular

Team

$149/mo

Check out our demo first — pay later

  • $10,000 / month governed spend
  • 10,000 evaluations included
  • Unlimited agents
  • Slack / Teams approval queues
  • 90-day audit history
  • Admin, Approver & Viewer roles
  • Spend Protection Guarantee up to $500
Start with Team

Growth

$499/mo

Check out our demo first — pay later

  • $50,000 / month governed spend
  • Custom policy rule builders
  • Multi-rail: Stripe Issuing, Ramp, USDC (your own accounts)
  • MCP server endpoints
  • 1-year audit retention
  • Spend Protection Guarantee up to $2,500
  • Webhook integrations
Scale with Growth

Enterprise

$1,500+

Check out our demo first — pay later

  • Custom spend limits
  • SAML / SSO (set up with our team)
  • Full audit export for compliance reviews
  • Deployment options scoped per contract
  • Priority support & onboarding
  • Custom Spend Protection Guarantee cap
Talk to sales

Team overage: $0.50 per $100 spent above allowance, or $1.00 per 1,000 extra evaluations. Full details on the pricing page.

Spend Protection Guarantee

If our policy enforcement fails and an agent payment goes through against your rules, we refund it: up to $500 on Team, $2,500 on Growth and a custom cap on Enterprise.

See what's covered →