Which integrations are available for this server?

Enables biometric-approval-gated API calls to DigitalOcean with credentials stored securely in the SynAuth vault. Enables biometric-approval-gated API calls to GitHub with credentials stored securely in the SynAuth vault. Enables biometric-approval-gated API calls to OpenAI with credentials stored securely in the SynAuth vault. Enables biometric-approval-gated API calls to Stripe with credentials stored securely in the SynAuth vault.

How do I use synauth-mcp?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@synauth-mcp approve sending an email to the team about the meeting" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

synauth-mcp

by dennischoubot-glitch

Overview Schema Related Servers Score Discussions

Python

Remote

SynAuth MCP Server

Biometric authorization for AI agent actions. Every sensitive action your AI agent takes — sending emails, making purchases, accessing data, signing contracts — goes through Face ID verification on your iPhone.

This is the MCP (Model Context Protocol) server. It works with Claude, Cursor, and any MCP-compatible agent. For direct Python integration, see the SynAuth SDK.

Install

pip install synauth-mcp

Related MCP server: AgentValet

Configure

Add to your Claude configuration (~/.claude/claude_desktop_config.json):

{
  "mcpServers": {
    "synauth": {
      "command": "synauth-mcp",
      "env": {
        "SYNAUTH_API_KEY": "aa_your_key_here"
      }
    }
  }
}

Restart Claude. The agent now has access to SynAuth tools.

Setup: From Zero to First Approval

1. Get the SynAuth iOS app. Download from the App Store. Create an account.

2. Get your API key. The app generates an API key when you create your account. Copy it — this is what connects your agent to your phone.

3. Configure your agent. Add the MCP config above with your API key.

4. (Optional) Store credentials in the vault. In the SynAuth app, go to the Vault tab and add your API credentials (OpenAI, GitHub, Stripe, etc.). This enables the vault execution model — your agent can use these services without ever seeing the keys.

5. Try it. Ask your agent to do something that requires approval — "send an email to team@company.com" or "check my OpenAI usage." Your iPhone will light up with a Face ID prompt.

How It Works

Your Agent (Claude, Cursor, etc.)
    │
    ├─ request_approval("Send email to team@co.com")
    │       │
    │       ▼
    │   SynAuth Backend ──── push notification ───▶ iPhone
    │       │                                        │
    │       │                                    Face ID ✓
    │       │                                        │
    │       ◀──────────── approved ──────────────────┘
    │
    ├─ (Approval-only mode) Agent executes the action itself
    │
    └─ (Vault mode) execute_api_call("openai", "POST", "https://api.openai.com/...")
            │
            ▼
        SynAuth injects stored credential, makes the API call
            │
            ▼
        Response returned to agent (agent never saw the API key)

There are two modes:

Approval-only — The agent asks permission, then acts with its own credentials. Good for actions where the agent already has access but needs human sign-off.
Vault execution — The agent asks permission, then SynAuth executes using stored credentials. The agent never touches the real API keys. This is structural enforcement — the agent can't bypass what it can't access.

Why This Exists

Most agent approval systems work like this: agent has your API keys, agent asks "can I use them?", you click a button in Slack. If the agent ignores the answer — or if someone else clicks the button — it still has the keys.

SynAuth works differently:

Face ID, not buttons. Proves the authorized person approved it — not just someone with Slack access.
Vault execution. The agent doesn't have your API keys. SynAuth does. After biometric approval, SynAuth makes the API call and returns the result. The agent gets the output without ever seeing the credential.
Audit trail with identity proof. Every action is logged with biometric verification — not a click timestamp.

	SynAuth	Slack/Email Buttons
Verification	Face ID (biometric)	Click a button (anyone with access)
Credential safety	Agent never sees keys	Agent often has direct key access
Audit trail	Every action logged with biometric proof	Click timestamp at best
Compliance	Proves physical identity of approver	Proves someone had Slack access

Usage Examples

Approve an email

Your agent decides to send an email. It requests approval, waits for your Face ID, then proceeds:

Agent: I'll send the quarterly report to investors@company.com.
       Let me get approval first.

→ request_approval(
    action_type: "communication",
    title: "Send quarterly report to investors@company.com",
    description: "Q4 2025 financial results and outlook",
    risk_level: "low"
  )

← { "id": "req_abc123", "status": "pending" }

→ wait_for_approval(request_id: "req_abc123")

  [Your iPhone buzzes. You glance, see "Send quarterly report
   to investors@company.com", verify with Face ID.]

← { "id": "req_abc123", "status": "approved", "resolved_by": "face_id" }

Agent: Approved. Sending now.

Make a purchase (with spending limits)

Before buying something, the agent checks spending limits, then requests approval:

Agent: You asked me to buy DigitalOcean credits. Let me check the budget.

→ get_spending_summary()

← { "summaries": [
     { "period": "monthly", "limit": 500.00, "spent": 120.00,
       "remaining": 380.00, "utilization_pct": 24.0 }
   ] }

Agent: You have $380 remaining this month. Requesting approval for $49.99.

→ request_approval(
    action_type: "purchase",
    title: "Purchase DigitalOcean credits",
    amount: 49.99,
    recipient: "DigitalOcean",
    risk_level: "medium"
  )

→ wait_for_approval(request_id: "req_def456")

  [Face ID prompt on your iPhone shows: "Purchase DigitalOcean
   credits — $49.99"]

← { "status": "approved" }

Call an API through the vault

This is the key differentiator. Your agent needs to call the GitHub API, but it doesn't have your GitHub token — SynAuth does:

Agent: I'll create the repository. Let me check what services
       are available.

→ list_vault_services()

← { "services": [
     { "service_name": "github", "auth_type": "bearer",
       "allowed_hosts": ["api.github.com"] },
     { "service_name": "openai", "auth_type": "bearer",
       "allowed_hosts": ["api.openai.com"] }
   ] }

→ execute_api_call(
    service_name: "github",
    method: "POST",
    url: "https://api.github.com/user/repos",
    headers: { "Content-Type": "application/json" },
    body: '{"name": "new-project", "private": true}',
    description: "Create private repo 'new-project' on GitHub"
  )

  [Face ID prompt: "Create private repo 'new-project' on GitHub"]

← { "status": "approved", "response": { "status_code": 201, ... } }

The agent provided the request details. SynAuth showed you what it wanted to do. You verified with Face ID. SynAuth injected your GitHub token and made the API call. The agent got the response but never saw the token.

Security properties of vault execution:

URL host validation — The GitHub token can only be sent to api.github.com. If the agent tries to send it elsewhere, the request is rejected.
Single-use — Each approval authorizes exactly one API call. The agent can't reuse an old approval.
Credential isolation — The agent's environment has only a SynAuth API key. No GitHub tokens, no OpenAI keys, no Stripe secrets.

Review past actions

→ get_approval_history(limit: 5)

← { "actions": [
     { "title": "Send quarterly report", "status": "approved",
       "resolved_at": "2025-02-18T10:30:00Z" },
     { "title": "Purchase DigitalOcean credits", "status": "approved",
       "amount": 49.99, "resolved_at": "2025-02-18T10:15:00Z" },
     { "title": "Post to Twitter", "status": "denied",
       "deny_reason": "Content needs review" }
   ] }

Available Tools

Tool	What it does
`request_approval`	Submit any action for biometric approval. Returns immediately with status.
`check_approval`	Check current status of a pending request.
`wait_for_approval`	Block until the request is approved, denied, or expired.
`get_spending_summary`	Check spending against configured limits before making purchases.
`get_approval_history`	Review past approved, denied, and expired actions.
`list_vault_services`	See which API credentials are stored in the vault.
`execute_api_call`	Make an API call through the vault — biometric approval + credential injection.

Rules Engine

Not every action needs a Face ID prompt. SynAuth has a rules engine that can auto-approve or auto-deny based on:

Action type — Auto-approve low-risk scheduling, require approval for legal actions
Risk level — Low-risk actions auto-approve, critical actions always require Face ID
Amount — Purchases under $10 auto-approve, over $100 require approval
Agent ID — Different rules for different agents

You configure rules in the iOS app. The agent doesn't need to know about rules — it just calls request_approval and gets back either "status": "approved" (auto-approved by rule) or "status": "pending" (waiting for Face ID).

Action Types

Type	Examples	Default Risk
`communication`	Emails, messages, notifications	low
`purchase`	Buying, subscriptions, payments	medium
`scheduling`	Bookings, reservations, calendar	low
`legal`	Contracts, terms, agreements	critical
`data_access`	Database queries, file downloads	high
`social`	Social media posts, profile updates	medium
`system`	Config changes, restarts, deployments	high

Environment Variables

Variable	Required	Default	Description
`SYNAUTH_API_KEY`	Yes	—	Your SynAuth API key (starts with `aa_`)
`SYNAUTH_URL`	No	`https://synauth.fly.dev`	Backend URL (override for self-hosted)

Also Available

synauth — Python SDK for direct integration (convenience methods, typed errors, spending limits)
SynAuth iOS App — Face ID approval on your iPhone
REST API — https://synauth.fly.dev/api/v1/ for any language

License

MIT

Available Tools

7 tools

check_approvalA

Check the status of an approval request.

Returns the current status (pending, approved, denied, expired) and full details including timestamps, resolution method, and any deny reason.

Use this after request_approval to see if the human has responded.

ParametersJSON Schema

Name	Required	Description	Default
`request_id`	Yes	The request ID returned by request_approval

TDQS

A4.5/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It adequately discloses the tool is a read operation that returns status and details, but doesn't explicitly state idempotency or safety. Still, the behavior is transparent enough for this simple query.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Concise three sentences, front-loaded with purpose, no unnecessary words. Every sentence adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the simple single-parameter schema and no output schema, the description adequately covers what the tool does and what it returns, including specific fields like timestamps and deny reason.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema covers the single parameter request_id with a description. The tool description also mentions it, reinforcing the meaning. No additional semantics needed beyond what's in the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool checks approval status, specifies the returned information (status, timestamps, resolution method, deny reason), and distinguishes itself from sibling tools like request_approval and wait_for_approval.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly advises to use after request_approval to check human response. Provides clear timing context, though it doesn't explicitly state when not to use (e.g., if waiting is desired).

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

execute_api_callA

Make an API call using a credential stored in SynAuth's vault.

This is the core structural enforcement tool: the agent provides the request details, SynAuth requests biometric approval, then executes the call with the stored credential. The agent never sees the raw API key or token.

Flow:

You provide: service name, HTTP method, URL, optional headers and body
SynAuth sends a push notification to the user's iPhone
User approves via Face ID
SynAuth injects the stored credential and makes the HTTP request
Response is returned to you

The URL must match one of the service's allowed hosts (security: prevents credential exfiltration). Each approval is single-use — you cannot re-execute the same approved request.

Example: Call OpenAI API service_name: "openai" method: "POST" url: "https://api.openai.com/v1/chat/completions" headers: {"Content-Type": "application/json"} body: '{"model": "gpt-4", "messages": [{"role": "user", "content": "Hello"}]}'

ParametersJSON Schema

Name	Required	Description
`service_name`	Yes	Name of the vault service (use list_vault_services to see available)
`method`	Yes	HTTP method
`url`	Yes	Full URL to call (host must be in service's allowed_hosts)
`headers`	No	Additional headers (auth header is injected automatically)
`body`	No	Request body (typically JSON string for POST/PUT/PATCH)
`description`	No	Human-readable description shown in the approval prompt
`timeout_seconds`	No	Max seconds to wait for approval (default: 120)

TDQS

A4.4/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, description fully covers behavior: biometric approval, single-use approvals, credential injection, agent never sees key, URL host restriction, and timeout. Transparent about flow and security.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Well-structured with summary, step-by-step flow, security note, and example. Slightly verbose but every detail contributes; could be more concise without losing clarity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Covers purpose, flow, and security well, but lacks description of return value structure and error handling (e.g., user denial, invalid URL). Without output schema, additional detail would improve completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage 100% means baseline 3, but description adds value by explaining purpose of each parameter (e.g., headers as additional, body for JSON, timeout for approval wait), providing an example, and clarifying description parameter usage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states the tool makes API calls using stored credentials, with explicit flow and security enforcement. It distinguishes from sibling tools like list_vault_services by explaining it's the core execution tool.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides clear usage context: required when making API calls with vault credentials, flows step-by-step, and notes security constraint (URL matching allowed hosts). However, does not explicitly contrast with siblings or state when not to use.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_approval_historyA

Get history of resolved approval requests.

Returns past approved, denied, and expired requests. Useful for reviewing what actions have been taken and their outcomes.

ParametersJSON Schema

Name	Required	Description	Default
`limit`	No	Max number of results (default: 20)
`action_type`	No	Filter by action type (optional)

TDQS

A4/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It mentions the returned statuses but omits details like authentication requirements or rate limits.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences with front-loaded information: verb and resource first, then value proposition. No wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Clear on what is returned (resolved requests with outcomes), but could specify default ordering or pagination details given no output schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema covers all parameters with descriptions, so baseline is 3. The description adds no additional meaning beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves history of resolved approval requests and specifies the types included (past approved, denied, expired), distinguishing it from siblings like request_approval.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The phrase 'Useful for reviewing what actions have been taken and their outcomes' implies its usage context, but no explicit when-not-to-use or alternatives are mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_spending_summaryA

Check your current spending against configured limits.

Returns all spending limits that apply to you (agent-specific and global limits), with your current spend, remaining budget, and utilization percentage for each.

Use this BEFORE making purchases or other monetary actions to check if you have budget remaining. This prevents hitting spending limit denials.

Each summary includes: limit_id, period (daily/weekly/monthly), limit amount, spent amount, remaining amount, and utilization percentage.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

TDQS

A4.6/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, but description explains it returns spending limits and current spend, implying read-only behavior. Does not explicitly state it is non-destructive, but the nature of the tool is clear.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Concise at 4-5 sentences, each sentence adds value. Front-loaded purpose, followed by return details and usage guidance. No redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Description covers purpose, usage guidance, and return fields. Missing explicit mention of read-only nature or error conditions, but adequate for a simple parameterless tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

No parameters exist, and schema coverage is 100%. Baseline score of 4 applies as description does not need to add parameter details.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states it checks spending against limits and returns a summary with specific fields. It distinguishes from sibling tools (approvals, vault services) by focusing on budget status before monetary actions.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly advises using this tool before making purchases or monetary actions to check budget, preventing spending limit denials. Provides clear context on when to use.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_vault_servicesA

List available vault services (stored API credentials).

Shows which services have credentials stored in SynAuth's vault. Each service has allowed hosts that restrict where credentials can be sent. The agent never sees the actual credential values — only service names and metadata.

Use this to discover what API services are available before calling execute_api_call.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

TDQS

A4.5/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden. It discloses that the agent never sees actual credential values, only names and metadata, and mentions allowed hosts restriction. This is sufficient transparency for a list tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise (four sentences) and front-loaded with the purpose. Every sentence adds necessary information without redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given that the tool has no parameters and no output schema, the description provides complete context: purpose, what is returned (metadata, not credentials), and usage in relation to a sibling tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

There are no parameters, so baseline 4 applies. The description adds value by explaining what the output contains (service names and metadata), which complements the input schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states that the tool lists vault services (stored API credentials). It uses specific verb 'list' and resource 'vault services', and distinguishes from sibling 'execute_api_call' by indicating that it is a discovery step before that call.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly says 'Use this to discover what API services are available before calling execute_api_call.' This provides clear context and connects to a sibling tool, though it does not explicitly state when not to use it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

request_approvalA

Request human approval for an AI agent action via Face ID.

Submit any action (email, purchase, booking, contract, data access, social post, system change) for biometric verification by the authorized human. Returns immediately with request ID and initial status — the action may be auto-approved/denied by rules, or pending human review.

Action types: communication, purchase, scheduling, legal, data_access, social, system Risk levels: low, medium, high, critical

Example: Request approval to send an email action_type: "communication" title: "Send quarterly report to john@company.com" risk_level: "low"

Example: Request approval for a $500 purchase action_type: "purchase" title: "Purchase cloud hosting credits" amount: 500.00 risk_level: "medium"

ParametersJSON Schema

Name	Required	Description	Default
`action_type`	Yes	Category of the action
`title`	Yes	Short description shown to the approver
`description`	No	Detailed description of the action (optional)
`risk_level`	No	Risk classification (affects UI urgency and rule evaluation)	medium
`amount`	No	Dollar amount, if applicable (e.g., purchases)
`recipient`	No	Who receives the action (email address, merchant name, etc.)
`reversible`	No	Whether the action can be undone
`metadata`	No	Arbitrary key-value pairs for audit trail
`expires_in_seconds`	No	Seconds until the request auto-expires (default: 5 minutes)
`callback_url`	No	HTTPS URL to receive webhook when approval status changes (optional)

TDQS

A4.3/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description discloses key behaviors: returns immediately with request ID and status, can be auto-approved/denied or pending, and uses biometric verification. It does not contradict any annotations (none provided). However, it could add more detail about potential failures or cancellation behaviors.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured: a concise summary, followed by lists of action types and risk levels, and two illustrative examples. It is appropriately sized for a complex tool with 10 parameters, though slightly longer than necessary. Every section adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the 10 parameters, 100% schema coverage, and no output schema, the description sufficiently covers the tool's purpose, parameters, and behavior. It explains return values (request ID and status) and includes examples. Additional details about output format or error handling would increase completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema already has 100% parameter description coverage, so the baseline is 3. The tool description adds value beyond the schema by providing examples, explaining how risk_level affects UI urgency, and showing typical use cases for amount and action_type. This justifies a 4.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: requesting human approval for AI actions via Face ID. It lists specific action types and risk levels, and provides examples that illustrate usage for different scenarios. The sibling tools include check_approval and get_approval_history, which are distinct, so the tool stands out clearly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explains when to use the tool (when human approval is needed) but does not explicitly state when not to use it or compare it with alternatives like check_approval or wait_for_approval. The examples give good context, but explicit guidance on avoiding this tool for non-approval actions would improve clarity.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

wait_for_approvalA

Wait for an approval request to be resolved.

Polls the backend until the request is approved, denied, or expired. Returns the final status. Use this when you need to block until the human responds.

Default timeout is 120 seconds with 3-second polling intervals.

ParametersJSON Schema

Name	Required	Description
`request_id`	Yes	The request ID to wait on
`timeout_seconds`	No	Max seconds to wait (default: 120)
`poll_interval`	No	Seconds between status checks (default: 3)

TDQS

A4.2/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Without annotations, the description discloses polling behavior, final status return, and default timeout/interval. It mentions outcomes (approved, denied, expired) but omits error handling or cancellation behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Very concise: 4 sentences cover purpose, mechanism, return, usage, and defaults with no unnecessary words. Front-loaded with the core action.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Covers the core workflow, blocking behavior, and defaults. Lacks explicit mention of timeout result (implied 'expired') and return format, but overall sufficient for a parametric wait tool with no output schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with descriptions already provided. The description repeats default values but adds no new meaning beyond the schema, earning the baseline score.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Wait for an approval request to be resolved' with a specific verb and resource. It distinguishes from sibling 'check_approval' by noting it blocks until human responds.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly says 'Use this when you need to block until the human responds,' guiding when to use. It does not explicitly list alternatives but implies that non-blocking check is available via sibling tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4.4/5.0

Disambiguation5/5

Each tool has a distinct purpose: requesting approval, checking status, waiting, viewing history, listing services, executing API calls, and checking spending. No overlaps.

Naming Consistency5/5

All tools use consistent verb_noun snake_case naming (e.g., check_approval, execute_api_call, list_vault_services).

Tool Count5/5

7 tools cover the core functionality of a credential/approval system without being excessive or insufficient.

Completeness4/5

Covers the main approval lifecycle and API execution flow. Minor gap: no tool to list pending approvals or cancel requests, but core workflows are supported.

Maintenance

ActivityInactive

ResponsivenessSyncing

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

agentdevx C
io.github.mirajmahmudul
Give your AI hands. Identity, credential vault, and API gateway for autonomous agents.
Agent Orchestration Developer Tools
382
mcp
com.decionis
Authorize consequential AI agent actions before execution
Security Agent Orchestration
1
agentlock
io.github.Olum289
Security gateway for AI agents: policy, approval, and audited execution, no secrets shared.
Security Agent Orchestration
2
STACK
io.github.getstack-run
Command your AI agents: verifiable passports, credential injection, full audit, revoke in 60s.
Security Autonomous Agents Agent Orchestration
2

Related MCP Servers

AgentPay MCP Server
Security Autonomous Agents
Rumblingb
F
license
Not graded
quality
A
maintenance
Provides a trust and governance layer for AI agents, enabling secure API access, credential vaulting, paid execution with human approval, and automatic call resume.
Updated 3 days ago (2026-08-31 07:17 UTC)
15
2
AgentValetofficial
Security Autonomous Agents
AgentValet
A
license
A
quality
A
maintenance
Identity and credential governance for AI agents. Every agent gets its own cryptographic identity, scoped short-lived credentials per platform, human approval on sensitive actions, and an immutable audit log.
Updated 21 days ago (2026-08-12 11:13 UTC)
7
1
MIT
agent-auth
Security Browser Automation
ex-nihilo-labs
A
license
Not graded
quality
D
maintenance
Zero-knowledge credential injection for AI agents. Your agent authenticates to websites and APIs without ever seeing a password, TOTP code, or API key.
Updated 5 months ago (2026-04-11 19:39 UTC)
6
1
MIT
bw-proxy
Security Command Line
KpihX
A
license
D
quality
D
maintenance
Enables secure Bitwarden organization vault control with AI agents, featuring human-in-the-loop approval, ACID-compliant transactions, and redacted access to keep secrets hidden from LLMs.
Updated 4 months ago (2026-04-27 22:36 UTC)
10
MIT

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/dennischoubot-glitch/synauth-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

SynAuth MCP Server

Install

Configure

Setup: From Zero to First Approval

How It Works

Why This Exists

Usage Examples

Approve an email

Make a purchase (with spending limits)

Call an API through the vault

Review past actions

Available Tools

Rules Engine

Action Types

Environment Variables

Also Available

License

Available Tools

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

AgentValetofficial

Latest Blog Posts

MCP directory API