The
auth layer
for the agent economy
User-mediated, scoped authorization for AI agents.
Whether it's your agent managing your business or your users' agents accessing their data, AgentAdmit gives users control. Scoped. Revocable. Auditable.
Build and test with test keys. Pay when you're ready to go live.
The Problem & The Solution
AI agents need app access. Current approaches fall short.
As AI agents become the primary way users interact with apps and services, secure authorization with real user control is no longer optional.
The Problem
Credentials Flow Through Automated Channels
Most AI agent auth relies on API keys, redirects, or environment variables. These are channels that can be intercepted through prompt injection or misconfiguration.
How AgentAdmit Solves It
User-Mediated Delivery
The credential is delivered to the human. The human gives it to their agent. No redirect, no callback, no automated path between your app and the agent.
The Problem
Limited Control Over Agent Access
Most approaches give agents broad credentials. There’s no way to choose which specific actions an agent can perform, set how long access lasts, or revoke a single agent’s connection without affecting others.
How AgentAdmit Solves It
Scoped, Time-Limited, and Revocable
You and your users choose exactly what each agent can access, for how long, and can revoke any individual connection at any time from the dashboard.
The Problem
Agent Onboarding Requires Multiple Steps
Connecting an agent to a new app typically requires documentation, endpoint configuration, and multi-step auth flows.
How AgentAdmit Solves It
One Token, Fully Operational
The agent receives a single token, exchanges it, and gets back access along with everything it needs to operate. Scopes, endpoints, and schemas. No separate documentation or configuration needed.
Who Is This For
App owners, MCP operators, and your users.
App Owners
Give your own AI agent scoped access to your app's admin side. Let it monitor your business, optimize operations, and handle routine tasks. Set the scopes and set the duration. Want full automation? Set up crons to keep your agent running on autopilot. You monitor everything from your dashboard.
Examples: SaaS platforms, fitness apps, CRMs, e-commerce stores, analytics dashboards, content platforms, project management tools.
Your App Users
Your users want to connect their own AI agents to your app. AgentAdmit lets you offer that as a feature. Each user selects what their agent can access, for how long, and can revoke anytime. Their agent works within the permissions they chose. You get a new engagement channel, a stickier product, and full visibility into every agent connection from your dashboard.
Examples: Any user with a personal AI agent that can make API calls. Claude Code, Codex, OpenClaw, Gemini CLI, custom agents, automation platforms.
MCP Server Operators
Turn your MCP server into a business. $0 to start — you set your pricing, your users subscribe and select their scopes through a hosted consent page on AgentAdmit. We handle billing, user auth, and payouts. You keep 80%. Give your own AI agent scoped admin access to monitor operations. Use test keys to validate in staging before production.
Examples: Database tools, file system bridges, calendar integrations, API connectors, code execution environments, data pipelines.
Your MCP Users
Your users visit a hosted consent page where they sign in, select exactly which tools their agent can access, choose a duration, and get their token. No all-or-nothing API keys. They control their own permissions and can revoke anytime. You get per-user visibility, per-tool permissions, and a full audit trail.
Examples: Developers, teams, and businesses connecting their AI agents to your MCP tools for database access, file operations, API calls, and more.
Integrate in a day. Not a quarter.
You, your developer, or your AI agent can handle the entire integration. Then use test keys to validate real staging and end to end agent workflows before production.
Install the SDK
pip install agentadmit, npm install @agentadmit/sdk, or any of our 12 framework integrations. One command.
pip install agentadmit agentadmit init
Define your scopes
Tell AgentAdmit what your app can do. Read scopes for data access. Write scopes for actions. You decide what agents can and can't touch.
scopes:
- name: "read:orders"
description: "View order history"
- name: "manage:inventory"
description: "Update stock levels"Add one line of middleware
The SDK handles token validation, scope enforcement, and audit logging. Your existing API logic doesn't change.
app.add_middleware(
AgentAdmitMiddleware
)
@app.get("/api/orders")
@require_scope_if_agent("read:orders")
async def get_orders():
# your existing codeYour users connect their agents
Users click "AgentAdmit" in your app, select scopes, choose a duration, and get a token. The token is self-describing. Their agent extracts where to exchange it directly from the token itself. After exchange, the agent gets back access along with everything it needs to operate: scopes, endpoints, and schemas. No documentation or configuration needed. If you set up dynamic templates, users can also personalize a prompt and copy it with their token included.
Building or operating an MCP server?
AgentAdmit gives you user-controlled authorization.
MCP supports authentication, but authentication alone doesn't give you per-user, per-tool scoped access that your users control. AgentAdmit is the missing layer between MCP and user-controlled agent authorization.
Today's Challenge
Every agent that connects gets the same access to every tool. You don't know which user sent it. You can't give one agent read-only while another gets full access. Revoking individual agent access is difficult. Scaling to more users means scaling the risk.
With AgentAdmit
Each user selects exactly which tools their agent can access and for how long. You know which user is behind every call. Per-tool permissions. Full audit trail you can use for billing and compliance. You can revoke any agent connection from your admin panel. Your users can revoke their own agent's access at any time. Turn your MCP server into a production service with user-controlled, scoped agent access.
Same SDKs. $0 to start.
Python, Node, Go, Java, PHP, and Ruby SDKs all support MCP integration out of the box. $0 upfront for MCP operators — you keep 80% of your user subscriptions. AgentAdmit handles billing, user auth, and the hosted consent page. Your AI agent or developer can integrate in a day.
# MCP tool handler - add 3 lines
async def handle_tool_call(name, args):
token = args.pop("agentadmit_token")
ctx = await verify_agentadmit_token(token)
check_scope(ctx, required_scope_for(name))
return await run_tool(name, args)🖥️ Run your server like a business
- • See every active connection: which users, which agents, which tools
- • Full audit trail of every tool call. Use it for usage-based billing
- • Monitor agent behavior across your entire user base
- • Revoke any connection directly from the panel if you detect abuse
- • View and manage all connections from your dashboard
🤖 Use your own AI agent to run your operations
- • Give your own AI agent scoped admin access to your server
- • Set the scopes and set the duration for your agent's access
- • Want full automation? Set up crons and your agent can monitor usage, alert you on unusual patterns, and handle routine tasks while you sleep
- • Scoped, user-controlled access for your users and for your own operations
See the code
Install the SDK. Add one line of middleware. Your existing API logic doesn't change. The SDK handles token validation, scope enforcement, and audit logging automatically.
# Install: pip install agentadmit
from agentadmit import AgentAdmitMiddleware
from agentadmit import require_scope_if_agent
from agentadmit import get_current_user_or_agent
# One-line middleware setup
app.add_middleware(AgentAdmitMiddleware,
config_path="agentadmit.yaml",
get_current_user=your_auth,
verify_user_token=your_verifier,
)
# Add to any route - existing code unchanged
@app.get("/api/orders")
async def get_orders(
auth=Depends(get_current_user_or_agent),
_=Depends(require_scope_if_agent("read:orders")),
):
return get_orders_for(auth["user"]["user_id"])Also available for Flask, Django, Next.js, Spring Boot, Laravel, Ruby on Rails, Gin, and Echo.
Plus drop-in React components for the AgentAdmit page.
12 framework integrations. One standard.
Built for the agent economy
Everything you need to let AI agents access your app. Securely, with user consent, and fully managed.
User-Mediated Security
The token goes to the human, not the agent. The architecture has no redirect, callback, webhook, or polling endpoint that delivers credentials to agents through automated channels. The user is always the trust bridge.
One Token, Fully Operational
Your agent receives a single token and extracts where to exchange it directly from the token itself. After exchange, it gets back access along with everything it needs to operate. Scopes, available endpoints, and request schemas. No documentation. No configuration. One token.
Caller-Identity Consent
Your users control access for three types of callers independently: human sessions, your app’s own AI features, and external AI agents. Each has its own consent. One doesn’t grant another. A user can approve your AI features while declining external agent access, or any combination.
12 Frameworks, One Standard
Python (FastAPI, Flask, Django), Node.js (Express, Next.js), Java (Spring Boot), PHP (Laravel), Ruby (Rails), Go (net/http, Gin, Echo). Plus drop-in React components. Install and go.
Agent-Agnostic
Designed to work with AI agents that can make HTTP requests. Claude Code, Codex, OpenClaw, Gemini CLI, and any custom agent built with function calling. If it can call an API, it can use AgentAdmit.
User-Controlled Duration
Users choose how long their agent stays connected. For example: 1 hour, 7 days, or until they revoke. Enables cron-based automation for business owners.
Dynamic Templates
Define prompt templates for your app. When your users select scopes, only the relevant templates appear automatically. Users can personalize, copy with their token included, and give to their agent. You build the templates. We make them dynamic.
Full Audit Trail
Every agent API call is validated through mandatory introspection and logged automatically. Every request records which agent, which user, which scope, which resource, and the result. Use it for compliance, abuse detection, or usage-based billing.
Security Alerts & Kill Switch
Automatic anomaly detection on every connection. Volume spikes, unauthorized scope probing, dormant connection reactivation. Configurable alert thresholds for app owners. Users can tighten alerts on their own connections. Optional kill switch auto-revokes connections when thresholds are breached. Included in every tier.
Monitor and Control from Your Dashboard
View all agent connections, usage metrics, and billing status. Revoke any connection from your dashboard. Your users can revoke their own agent access at any time. Give your own AI agent scoped admin access to monitor your app. Want full automation? Add crons. Works for app owners and MCP server operators.
Security
Security by architecture, not by policy
These aren't settings you can turn on or off. They're how the system is built.
Credentials Stored as Hashes
Connection credentials are stored only as cryptographic hashes. Plaintext credentials are not retained after delivery to the user.
One-Time Credential Redemption
Credentials are permanently invalidated on first use, regardless of whether the exchange succeeds or fails. A credential that has been used once cannot be replayed.
Agents Cannot Expand Their Own Access
There is no API for an agent to modify or escalate its own permissions. The only path to additional access is for the human to initiate a new connection.
Step-Up Authorization
When an agent requests an operation outside its granted scopes, the system identifies the additional scope required and directs the agent to request renewed authorization from the user.
Mandatory Introspection
Every agent API call is validated through introspection before it reaches your app. This is not optional or configurable. Every request is checked and logged.
Simple Pricing
Two paths. One platform. Pick what fits your business.
🔥 Early adopter pricing: First 1,000 app owners and first 1,000 MCP operators get 50% off for their first year. Offer ends 6 months after launch.
App Owners
Building an app? Add scoped AI agent authorization.
Starter
$25/mo for early adopters
- ✓250,000 API calls/month included
- ✓$0.30 per 1,000 additional calls
- ✓Self-describing tokens (patent pending)
- ✓Mandatory introspection & audit logging
- ✓User-controlled token duration
- ✓RS256-signed JWTs per app
- ✓Dashboard with analytics & audit logs
- ✓7 SDKs covering 12 framework integrationsPython — FastAPI, Flask, DjangoNode.js — Express, Next.jsGo — net/http, Gin, EchoJava — Spring BootPHP — LaravelRuby — RailsReact — Embeddable components
Builder
$50/mo for early adopters
- ✓500,000 API calls/month included
- ✓$0.25 per 1,000 additional calls
- ✓Self-describing tokens (patent pending)
- ✓Mandatory introspection & audit logging
- ✓User-controlled token duration
- ✓RS256-signed JWTs per app
- ✓Dashboard with analytics & audit logs
- ✓7 SDKs covering 12 framework integrationsPython — FastAPI, Flask, DjangoNode.js — Express, Next.jsGo — net/http, Gin, EchoJava — Spring BootPHP — LaravelRuby — RailsReact — Embeddable components
Pro
$100/mo for early adopters
- ✓1,000,000 API calls/month included
- ✓$0.20 per 1,000 additional calls
- ✓Self-describing tokens (patent pending)
- ✓Mandatory introspection & audit logging
- ✓User-controlled token duration
- ✓RS256-signed JWTs per app
- ✓Dashboard with analytics & audit logs
- ✓7 SDKs covering 12 framework integrationsPython — FastAPI, Flask, DjangoNode.js — Express, Next.jsGo — net/http, Gin, EchoJava — Spring BootPHP — LaravelRuby — RailsReact — Embeddable components
MCP Server Operators
Running an MCP server? Turn it into a business with user-controlled authorization.
You keep 80%. We only earn when you do.First 1,000 MCP operators: keep 90% for your first year.
You set your pricing — monthly subscriptions, prepaid credits per tool call, or both. Your users select their scopes through a hosted consent page on AgentAdmit. We handle billing, user auth, and payouts via Stripe Connect. You get paid automatically.
- ✓Hosted consent page — your users sign in, select scopes, get their token
- ✓Subscription tiers or prepaid credits per tool call — you set the pricing
- ✓Per-user, per-tool scoped authorization (patent pending)
- ✓Full audit trail — every tool call logged with user, scope, and result
- ✓Users control their own permissions and can revoke anytime
- ✓Same 7 SDKs and 12 framework integrations
How it works
Enterprise
Custom volume, custom pricing. Everything in the self-serve plans, tailored to your scale.
Build and test with test keys. Pay when you're ready to go live.
Ready to automate your business and take your time back?
Integrate in a day. From $50/mo for app owners. $0 to start for MCP server operators.
Set up your agent and get back to living your life. Want full automation? Add crons.
AgentAdmit is the authorization layer for AI agents. Hosted, managed, and patent pending.