Add Fine-Grained Authorization
in Minutes, Not Months

Stop writing brittle if-statements—and stop agents running wild. Compatible with AWS Cedar. Deterministic guardrails for apps, SaaS, and autonomous agents.

Authorization is Hard. Really Hard.

Complex to Build

Hundreds of if-statements. Nested permissions. Multi-role logic. Your codebase becomes a mess.

Months of Work

Design, implement, test, debug. Meanwhile, your actual product features wait.

Error-Prone

One wrong if-statement = security breach. Testing all edge cases is impossible.

Expensive

Enterprise auth tools cost $1000+/month. DIY takes 3-6 months of dev time.

Hard to Maintain

Every new feature needs permission logic. Technical debt grows exponentially.

No Visibility

Can't audit who has access to what. Compliance nightmares waiting to happen.

Security Risks

One permission bug = data breach. Your reputation and customer trust at stake.

Scalability Issues

What works for 10 users breaks at 1000. Refactoring auth is painful.

Enterprise Auth, Startup Simple

FastAuth gives you enterprise-grade authorization without the enterprise headache. Three lines of code. Zero infrastructure. Compatible with AWS Cedar—the same tech powering AWS Verified Permissions.

Built for modern applications
  • AI Agents & MCP Tools
  • Mobile apps
  • Web applications
  • SaaS products
Get Started
// Enforce a deterministic guardrail before an AI agent runs a tool
const result = await fastauth.authorize({
  principal: { type: 'Agent', id: 'support_bot', delegatedBy: 'alice' },
  action: 'issue_refund',
  resource: {
    type: 'Order',
    id: 'ord_901',
    customer: 'alice',
    amount: 2500
  }
});

if (result.decision === 'Allow') {
  await executeTool('issue_refund', order);
} else {
  await escalateToHuman(result.reasons); // Blocked by Cedar policy ✓
}
Authorization for Agents

Stop Agents Running Wild

Implement deterministic guardrails for autonomous agents. System prompts are probabilistic suggestions—AWS Cedar policies are hard enforcement checked before every tool call executes.

Immune to Prompt Injection

Prompt instructions can be bypassed; Cedar forbid rules cannot. Block unauthorized actions deterministically before a tool ever runs.

Scoped Delegation

Ensure an agent acts strictly for the invoking user (delegatedBy == resource.customer)—never with blanket admin credentials across tenants.

Blast-Radius & Spend Caps

Enforce hard ceilings on transaction amounts, forbid destructive deletes, and gate sensitive operations behind human approval in milliseconds.

Instant Agent Kill Switch

Issue isolated API keys per agent, track real-time Last used (UTC) timestamps, and make any misbehaving key inactive with zero disruption to others.

Why Developers Choose FastAuth

Compatible with AWS Cedar

Battle-tested policy engine used by AWS. Enterprise-proven, developer-friendly.

Transparent Debugging

See exactly which policies matched. Debug authorization issues in seconds.

Multi-Role Support

Users can have different roles across resources. Perfect for SaaS platforms.

Blazing Fast

0.2ms response time. 4,400 requests/second per instance. Zero database lookups.

Zero Dependencies

Stateless service. No Redis, no Postgres. Just fast authorization decisions.

Developer-Friendly

RESTful API, SDKs for all languages, comprehensive docs. Start in minutes.

Generous Free Tier

10,000 requests per month and up to 10 applications, free forever. Perfect for side projects.

Enterprise-Ready

Audit logs included. JWT auth. Multi-region deployment. Built for compliance.

See Demo

Tool Call Request
{
  "action": "issue_refund",
  "resource": {
    "type": "Order",
    "id": "ord_901",
    "customer": "alice",
    "amount": 2500
  }
}
Agent Principal (Delegated)
{
  "type": "Agent",
  "id": "support_bot",
  "delegatedBy": "alice"
}
Response
{
  "decision": "Deny",
  "evaluationTimeMs": 0.214,
  "matchedPolicies": ["forbid_agent_high_value_refund"]
}

✗ support_bot blocked from refunding $2,500
Reason: Exceeds $100 autonomous agent limit (human approval required)
Request
{
  "action": "edit",
  "resource": {
    "type": "document",
    "id": "doc_123",
    "owner": "alice"
  }
}
Principal (from JWT)
{
  "userId": "alice",
  "role": "Editor"
}
Response
{
  "decision": "Allow",
  "evaluationTimeMs": 0.226,
  "matchedPolicies": ["policy_editor_owns"]
}

✓ Alice can edit doc_123
Reason: Owner permission
Request
{
  "action": "delete",
  "resource": {
    "type": "document",
    "id": "doc_456",
    "owner": "bob"
  }
}
Principal (from JWT)
{
  "userId": "alice",
  "role": "Viewer"
}
Response
{
  "decision": "Deny",
  "evaluationTimeMs": 0.198,
  "matchedPolicies": []
}

✗ Alice cannot delete doc_456
Reason: Not owner + Viewer role
Request
{
  "action": "read",
  "resource": {
    "type": "project",
    "id": "proj_789",
    "workspace": "Engineering"
  }
}
Principal (from JWT)
{
  "userId": "charlie",
  "roles": [
    {"role": "Admin", "workspace": "Engineering"},
    {"role": "Viewer", "workspace": "Marketing"}
  ]
}
Response
{
  "decision": "Allow",
  "evaluationTimeMs": 0.243,
  "matchedPolicies": ["policy_admin_engineering"],
  "effectiveRole": {
    "role": "Admin",
    "workspace": "Engineering"
  }
}

✓ Charlie can read proj_789
Used: Admin role in Engineering

Compatible with Cedar Policies

See the actual policies behind the playground examples above

✗ Guardrail: Block High-Value Autonomous Agent Refunds

Allows an AI agent to act only for its delegating customer—and uses a deterministic Cedar forbid rule to block high-value refunds regardless of prompt input.

// Allow agent scoped actions only for the user who invoked it
permit(
    principal,
    action in [Action::"read_ticket", Action::"issue_refund"],
    resource
)
when {
    principal.type == "Agent" &&
    principal.delegatedBy == resource.customer
};

// Hard guardrail: prompt injections cannot override Cedar forbid
@id("forbid_agent_high_value_refund")
forbid(
    principal,
    action == Action::"issue_refund",
    resource
)
when {
    resource.amount > 100
};
Example from Playground:
  • Principal: support_bot (Agent delegated by alice)
  • Action: issue_refund
  • Resource: ord_901 (customer alice, amount 2500)
  • Result: ✗ DENY - Matched explicit forbid_agent_high_value_refund guardrail

✓ Allow: Owner Can Edit Their Document

This policy grants edit permission when the user is the document owner.

// Cedar Policy
permit(
    principal,
    action == Action::"edit",
    resource
)
when {
    principal.userId == resource.owner
};
Example from Playground:
  • Principal: alice (Editor role)
  • Action: edit
  • Resource: doc_123 owned by alice
  • Result: ✓ ALLOW - Alice owns the document

✗ Deny: Viewer Cannot Delete

Viewers only have read permission. No policy grants delete, so it's denied by default.

// Cedar Policy - Only allows reading
permit(
    principal,
    action == Action::"read",
    resource
)
when {
    principal.role == "Viewer"
};

// No policy allows "delete" for Viewer role
// Result: DENY by default
Example from Playground:
  • Principal: alice (Viewer role)
  • Action: delete
  • Resource: doc_456 owned by bob
  • Result: ✗ DENY - No matching policy

✓ Allow: Admin Can Access Any Resource in Their Workspace

Admins have full access to all resources within their workspace.

// Cedar Policy - Admin full access
permit(
    principal,
    action in [
        Action::"read",
        Action::"edit",
        Action::"delete"
    ],
    resource
)
when {
    principal.role == "Admin" &&
    principal.workspace == resource.workspace
};
Example from Playground:
  • Principal: charlie (Admin in Engineering)
  • Action: read
  • Resource: proj_789 in Engineering workspace
  • Result: ✓ ALLOW - Workspace matches

Write policies in plain English-like syntax. Cedar handles the complexity.

Start Using Cedar Policies

Simple, Transparent Pricing

Start building for free. Paid plans coming soon.

Starter

$29
per month
  • 200,000 requests/month + overages
  • Up to 20 applications
  • Up to 5 users & 1 team
  • In-console support cases
  • 99.9% uptime SLA
  • Audit logs (30 days)
Coming Soon

Pro

$99
per month
  • 1,000,000 requests/month + overages
  • Up to 100 applications
  • Up to 25 users & 5 teams
  • Multi-region: US, EU, Asia
  • Priority support cases
  • 99.95% uptime SLA
  • Audit logs (90 days)
Coming Soon

Enterprise

$299
per month
  • 10,000,000 requests/month + overages
  • Up to 1,000 applications
  • 100+ users & 50+ teams
  • Multi-region: US, EU, Asia
  • Enterprise SSO (SAML / OIDC)
  • Dedicated support cases & 99.99% SLA
  • Audit logs (90+ days)
Coming Soon

Frequently Asked Questions

How does FastAuth stop AI agents from running wild? ▼

System prompts are probabilistic and can be bypassed by prompt injection or hallucination. FastAuth puts a deterministic AWS Cedar check in front of every tool call. You enforce explicit permit rules (scoped to the delegating user) and hard forbid ceilings (spending limits, no deletes), and you can deactivate any agent's API key instantly if it misbehaves.

How is FastAuth different from Auth0? ▼

Auth0 focuses on authentication (who you are), while FastAuth focuses on authorization (what you can do). We're compatible with AWS Cedar, giving you enterprise-grade policies without the complexity. Plus, we're 4x faster and more transparent—you see exactly which policies granted access.

Can I migrate from my current auth system? ▼

Yes! FastAuth handles authorization only, so it works alongside your existing authentication (Auth0, Firebase, custom JWT). You keep your current login flow and add FastAuth for permission checks. Migration guides coming soon.

Is my data secure? ▼

FastAuth is stateless—we don't store your data. All context is passed in each request. We use industry-standard JWT authentication, TLS encryption, and are deployed on Google Cloud Platform following their security best practices. Your authorization policies and data remain completely under your control.

What's included in the Free tier? ▼

10,000 authorization requests per month and up to 10 applications, all core features including multi-role support, policy debugging, and community support. Perfect for side projects, MVPs, and early-stage startups. No credit card required.