Skip to main content
Glama
aarifmms

aarifmms/keyblind

by aarifmms

Keyblind — Blind AI to Your Keys

Encrypted secrets vault with MCP for AI agents. Secrets resolved at runtime, never leaked to LLM conversations.

npm version License: MIT

Why

Developers regularly leak API keys, passwords, and tokens to AI coding tools. 100,000+ LLM conversations with exposed secrets were found indexed by search engines in 2025.

AI agents read your .env files. They copy-paste secrets into conversations. They commit them accidentally. Keyblind stops this by keeping secrets encrypted at rest and resolving them at runtime — the plaintext value never touches the LLM transcript.

Related MCP server: enigmagent-mcp

How It Works

┌──────────┐     ┌────────────────┐     ┌─────────────────┐
│ AI Agent │ ──→ │  Keyblind MCP  │ ──→ │  Encrypted      │
│ (Claude) │     │  Server        │     │  SQLite Vault   │
│          │ ←── │  (16 tools)    │ ←── │  (AES-256-GCM)  │
└──────────┘     └────────────────┘     └─────────────────┘
      ↑                                        │
      │ secret value never appears             │ secrets never
      │ in conversation transcript             │ stored in plaintext

Quick Start

# 1. Install
npm i -g keyblind

# 2. Initialize your vault
keyblind init

# 3. Auto-configure MCP for Claude Code (one command)
keyblind setup-mcp

# 4. Store secrets
echo "sk-proj-abc123" | keyblind set OPENAI_API_KEY
keyblind set DATABASE_URL -    # prompts securely

# 5. Sandbox your .env (AI agents see fakes)
keyblind sandbox

# 6. Resolve a secret
keyblind get OPENAI_API_KEY

# 7. Run commands with secrets injected as env vars
keyblind run -- npm start

# 8. List all secrets (names only, values hidden)
keyblind list

That's it. After keyblind setup-mcp, restart Claude Code. Then just say "list my keyblind secrets" or "use my OPENAI_API_KEY" — the AI agent resolves secrets at runtime without ever seeing them in the transcript.

MCP Server

Keyblind is MCP-first — it works with every AI tool that speaks the Model Context Protocol (Claude Code, Cursor, Copilot, Windsurf, Cline, Zed).

Setup (automatic)

keyblind setup-mcp

This auto-configures Claude Code to use Keyblind. Works from any directory. For other editors, see editor-specific configs.

Setup (manual)

Add a .mcp.json to your project root, or use claude mcp add:

claude mcp add --scope user keyblind -- keyblind start

With biometric gate (Touch ID required before secrets are resolved):

keyblind unlock                      # Authenticate first
claude mcp add keyblind -- keyblind start --biometric

Session expires after 15 minutes. Requires Pro or Team license.

MCP Tools

Tool

Description

resolve_secret

Resolve a secret at runtime (value hidden from transcript)

store_secret

Encrypt and store a secret

list_secrets

List secret names (values never revealed)

delete_secret

Delete a secret

sandbox_env

Replace .env values with deterministic fakes

unsandbox_env

Restore real .env values from vault

audit_log

View secret resolution audit trail

totp_code

Generate a TOTP 2FA code for a stored config

totp_store

Store a TOTP configuration from otpauth:// URI

totp_list

List all stored TOTP configurations

totp_delete

Delete a TOTP configuration

create_share_link

Create encrypted, expiring share link for a secret

receive_share

Receive and decrypt a shared secret

deadman_status

Check dead man's switch status

deadman_checkin

Reset dead man's switch timer

sso_status

Check SSO/OIDC authentication status

Web Dashboard

Manage your secrets from a browser at app.keyblind.dev. Start the HTTP server:

keyblind start --http

Then sign in with your license key at app.keyblind.dev/login. Features:

  • View, add, copy, and delete secrets

  • Audit log with full access history

  • License management

  • Pro/Team tier status

Browser Extension

The Keyblind Chrome Extension detects and blocks secrets from being pasted into AI chat interfaces (Claude.ai, ChatGPT, Copilot).

Chrome Web Store

Features:

  • Detects 12+ API key formats (OpenAI, GitHub, Stripe, AWS, etc.)

  • Intercepts paste events on AI chat sites

  • Warning banner when secrets are detected

  • Popup with vault connection status

Located in browser-extension/. Load as unpacked extension from chrome://extensions.

Pricing

Free

Pro

Team

Price

$0

$79/year

$29/user/month

Secrets

5

Unlimited

Unlimited

Local vault

Sandbox / Unsandbox

MCP server

Dashboard

Browser extension

7 backends

Team vaults

Audit log

Secret sharing

Dead man's switch

TOTP 2FA

Biometric gate

SSO/OIDC

CI/CD integration

# Buy a license at keyblind.dev, then activate:
keyblind activate <your-license-key>

# Check your status
keyblind status

Backends

Keyblind supports multiple secret backends:

keyblind backends                          # List available backends
keyblind backend 1password                 # Switch to 1Password
keyblind backend bitwarden                 # Switch to Bitwarden

Backend

Read

Write

Requires

local (default)

Nothing

1password

op CLI

bitwarden

bw CLI

env

Nothing

aws

aws CLI

gcp

gcloud CLI

azure

az CLI

Keyblind vs Cloak

Keyblind

Cloak

Protocol

MCP (all editors)

VS Code extension only

Editors

Claude Code, Cursor, Copilot, Windsurf, Cline, Zed

VS Code, Cursor

Storage

AES-256-GCM SQLite

AES-256-GCM file

Backends

Local, 1Password, Bitwarden, Env, AWS, GCP, Azure

Local only

Sandbox

Deterministic HMAC fakes

AES-256-GCM encrypted

Web dashboard

✓ (app.keyblind.dev)

Browser extension

✓ (Chrome)

TOTP 2FA

Secret sharing

✓ (encrypted URL fragment)

Dead man's switch

Touch ID

✓ (macOS biometric gate)

CI/CD

keyblind run for env injection

Network

Zero (fully local)

Zero

License

MIT

Proprietary

Free tier

✓ (5 secrets)

Pro

$79/year (unlimited)

Security

  • AES-256-GCM encryption with PBKDF2 key derivation (600K iterations)

  • Machine-identity-bound key — encryption key XOR-wrapped with machine fingerprint

  • Zero network, zero telemetry — no cloud, no accounts, no analytics

  • Vault stored at ~/.keyblind/ with 0700 permissions

  • Deterministic sandbox fakes using HMAC-SHA256 per project + key name

CLI Reference

keyblind init                 Initialize the encrypted vault
keyblind set <name>           Store a secret (value from stdin)
keyblind set <name> -         Store a secret (prompts securely)
keyblind get <name>           Resolve and print a secret
keyblind list                 List all stored secrets
keyblind delete <name>        Delete a secret
keyblind setup-mcp            Auto-configure MCP for Claude Code
keyblind sandbox [.env]       Replace .env with deterministic fakes
keyblind unsandbox [.env]     Restore real .env values
keyblind run <command...>     Run command with secrets as env vars
keyblind start                Start MCP server (stdio — for AI agents)
keyblind start --http         Start MCP HTTP server (for dashboard)
keyblind start --biometric    Start MCP server with biometric requirement
keyblind backends             List available backends
keyblind backend <name>       Switch backend
keyblind activate <key>       Activate a Pro/Team license
keyblind deactivate           Remove current license
keyblind status               Show license and vault status
keyblind audit                Show secret resolution audit log
keyblind check --expired      List secrets past expiry
keyblind rotate <name>        Update a secret value
keyblind team init [path]     Create a shared team vault
keyblind team push <name>     Push a secret to team vault
keyblind team pull            Pull secrets from team vault
keyblind team list            List secrets in team vault
keyblind totp set <name>      Store TOTP 2FA config
keyblind totp code <name>     Generate current TOTP code
keyblind totp list            List all TOTP configs
keyblind totp delete <name>   Delete a TOTP config
keyblind share <name>         Create encrypted share link
keyblind receive <url>        Receive a shared secret
keyblind deadman setup        Configure dead man's switch
keyblind deadman checkin      Reset dead man's switch timer
keyblind deadman status       Show dead man's switch status
keyblind deadman disable      Disable dead man's switch
keyblind sso configure        Set up SSO/OIDC for team access
keyblind sso login            Authenticate via browser SSO
keyblind sso logout           Clear SSO session
keyblind sso status           Show SSO auth status
keyblind doctor               Run vault health check
keyblind generate <name>      Generate a strong random secret
keyblind import [.env]        Bulk import from .env file
keyblind export               Export all secrets
keyblind completions [shell]  Generate shell completion script

Development

git clone https://github.com/aarifmms/keyblind.git
cd keyblind
npm install
npm run build       # Compile TypeScript
npm test            # Run tests
npm run dev         # Watch mode

License

MIT

Available Tools

7 tools
audit_logA

View the audit log of secret resolutions, stores, and deletes. Shows who accessed which secret and when.

ParametersJSON Schema
NameRequiredDescriptionDefault
limitNoMaximum number of entries to return (default: 50)

TDQS

A3.5/5.0
Behavior2/5

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

No annotations are provided, and the description does not disclose behavioral traits such as pagination, rate limits, or permission requirements. While it implies a read-only operation, details on output format or limits beyond the 'limit' parameter are missing.

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 with two sentences. The first sentence front-loads the primary purpose, and the second adds detail without redundancy. Every sentence is necessary.

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?

Given no output schema or annotations, the description covers the basics but lacks details on ordering, environment scope, or whether entries are paginated. It is minimally adequate for a simple list tool.

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?

The schema has 100% coverage for the single 'limit' parameter, which is clearly described there. The description does not add extra meaning beyond what the schema provides, so baseline 3 is appropriate.

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 purpose: viewing the audit log of secret resolutions, stores, and deletes. It specifies the information shown (who accessed which secret and when), making it distinct from sibling tools like store_secret or list_secrets.

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

Usage Guidelines3/5

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

The description implies use for audit purposes but lacks explicit guidance on when to use this tool versus alternatives. No 'when-not-to-use' or specific conditions are mentioned, leaving room for ambiguity.

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

delete_secretC

Delete a secret from the vault.

ParametersJSON Schema
NameRequiredDescriptionDefault
nameYesThe name of the secret to delete

TDQS

C2.9/5.0
Behavior1/5

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

With no annotations, the description must disclose behavioral traits, but it lacks critical details like whether deletion is permanent, what happens on error, or required auth.

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 single-sentence description is concise without wasted words, though it omits useful context.

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

Completeness2/5

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

Given no output schema and no annotations, the description does not provide sufficient completeness for an agent to understand return behavior or error handling.

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?

The input schema covers the single parameter with a clear description, so the description does not add extra 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 deletes a secret from the vault, distinguishing it from sibling tools like store_secret, list_secrets, and resolve_secret.

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

Usage Guidelines2/5

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

No guidance is provided on when to use this tool versus alternatives, such as when deletion is irreversible or requires specific permissions.

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

list_secretsA

List all stored secret names (names only — values are never revealed in this listing).

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

A4/5.0
Behavior3/5

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

With no annotations provided, the description must disclose behavioral traits. It does highlight a critical constraint (values never revealed), but does not mention other behaviors such as idempotency, authentication requirements, or behavior when no secrets exist. The key trait is covered, but the overall burden is minimally met.

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 a single sentence that immediately states the action and scope, then adds a critical caveat. No unnecessary words; it is as concise as possible while being informative.

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 tool's simplicity (no parameters, no annotations, no output schema), the description adequately covers purpose and key limitation. However, it could explicitly state that the output is a list of strings, which is implied but not explicit. Still, it is fairly complete for the tool's complexity.

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 tool has no parameters, so schema coverage is 100%. Per rubric, 0 parameters baseline is 4. The description adds no extra parameter info (none needed), but clarifies the return contents (names only), which is relevant to the output not parameters.

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 'List all stored secret names' with a specific verb and resource, and explicitly distinguishes itself from value-revealing tools with 'values are never revealed in this listing'. This differentiates it from sibling tools like resolve_secret.

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

Usage Guidelines3/5

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

The description implies usage when only names are needed and values should not be exposed, but it does not explicitly state when to use this tool versus alternatives like resolve_secret or delete_secret. No direct guidance on when-not or prerequisites is given.

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

resolve_secretA

Resolve a secret by name using the configured backend (local vault, 1Password, Bitwarden, or env vars). Returns the decrypted value at runtime. The secret value is never visible in the LLM conversation transcript — it is resolved just-in-time for the current operation.

ParametersJSON Schema
NameRequiredDescriptionDefault
nameYesThe name of the secret to resolve (e.g., OPENAI_API_KEY, DATABASE_URL)

TDQS

A4/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 key behavioral traits: runtime resolution, decryption, and that the secret value is never visible in the LLM conversation transcript. This adds significant context beyond the schema. It does not cover potential errors or side effects but is sufficient for a simple read operation.

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 extremely concise: two sentences, front-loaded with the core action, followed by a critical security detail. Every sentence adds value, and there is no extraneous text. It is well-structured for quick comprehension.

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 low complexity (1 parameter, no output schema, no nested objects), the description covers the essential: what it does, how it works (backend-agnostic), and a key behavioral trait (invisibility). It could mention return value format or errors, but for a simple scalar retrieval, it is largely complete. The lack of output schema is compensated by stating 'Returns the decrypted value'.

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 description coverage is 100% for the single 'name' parameter. The description provides an example list of secret names but does not add meaning beyond the schema's description. According to the rubric, with high coverage, baseline is 3, and the description does not merit a higher 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 the action ('resolves a secret by name') and the resource ('secret using the configured backend'). It distinguishes from sibling tools like store_secret and delete_secret by focusing on retrieval. The verb+resource+context is specific and unambiguous.

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

Usage Guidelines3/5

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

The description implies usage for retrieving secret values but does not explicitly state when to use or not use this tool. It lacks guidance on alternatives among siblings (e.g., list_secrets for listing, store_secret for storing). The security note about invisibility provides some context but no clear exclusion criteria.

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

sandbox_envA

Replace real values in your .env file with deterministic fake values. Real values are encrypted and backed up to the vault. AI agents reading .env files will only see fakes. Use unsandbox_env to restore real values.

ParametersJSON Schema
NameRequiredDescriptionDefault
filePathNoPath to the .env file. Defaults to .env in current directory.

TDQS

A4.5/5.0
Behavior4/5

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

Without annotations, the description discloses key behaviors: encryption and backup of real values to vault, and that AI agents only see fakes. However, it lacks details on vault storage details or permissions, but is generally transparent.

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 concise sentences: first states the action, second explains consequences and sibling tool. No wasted words.

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?

For a simple mutation tool with one optional parameter and no output schema, the description covers purpose, behavior, and complementary tool. Complete enough for correct usage.

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?

Only one parameter (filePath) with a schema description. The tool description adds no extra semantic beyond the schema's own description, so baseline 3 applies given 100% schema coverage.

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 action: replace real .env values with deterministic fakes, encrypt and backup real values, and AI agents see fakes. It distinguishes itself from the sibling unsandbox_env.

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?

The description explicitly tells when to use this tool (to sandbox .env values) and when not (use unsandbox_env to restore real values), providing clear context and an alternative.

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

store_secretA

Store a secret in the encrypted vault. The value is encrypted with AES-256-GCM before storage. The secret value is never visible in the LLM conversation transcript after this call.

ParametersJSON Schema
NameRequiredDescriptionDefault
nameYesA unique name for the secret (e.g., OPENAI_API_KEY, DATABASE_URL)
valueYesThe secret value to encrypt and store

TDQS

A3.6/5.0
Behavior3/5

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

The description reveals AES-256-GCM encryption and that the secret is hidden from the LLM transcript, which is valuable for security. However, it does not state whether storing a duplicate name overwrites or errors, nor does it mention persistence duration or side effects. Without annotations, the description carries the burden but covers some key behaviors.

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 two sentences, front-loaded with the core action, and every sentence adds value (encryption method and privacy guarantee). No unnecessary 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?

The description covers the core operation, encryption, and transcript invisibility. However, it omits what happens on duplicate name (overwrite or error) and does not mention the return value (e.g., confirmation or ID). Given the tool's simplicity (2 params, no output schema), it is largely complete but has minor gaps.

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?

The input schema already provides clear descriptions for both parameters (name and value), achieving 100% coverage. The description adds no additional parameter-level meaning beyond the schema, so the baseline score of 3 is appropriate.

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 action ('Store a secret') and the resource ('encrypted vault'), with specific details about encryption and transcript invisibility. It effectively distinguishes the tool from siblings like list_secrets, delete_secret, and resolve_secret.

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

Usage Guidelines2/5

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

No guidance on when to use this tool versus alternatives (e.g., resolve_secret or list_secrets). The description does not specify prerequisites or context for usage, leaving the AI to infer without explicit direction.

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

unsandbox_envC

Restore real .env values from the vault. Reverses the sandbox operation.

ParametersJSON Schema
NameRequiredDescriptionDefault
filePathNoPath to the .env file. Defaults to .env in current directory.

TDQS

C2.9/5.0
Behavior2/5

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

No annotations are provided, so the description carries full burden. It states it restores real values and reverses sandbox, but lacks details on what 'restore' entails (overwrites file? requires vault access?), side effects, or return behavior.

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?

Two sentences, no wasted words. However, it may be too concise given missing behavioral details. Still earns the score for being well-structured.

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?

For a simple tool with one optional parameter and a clear sibling (sandbox_env), the description provides the basic purpose but lacks behavioral context and usage guidelines. Minimally adequate.

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% (one parameter fully described). The description does not add any additional meaning beyond the schema. Baseline score of 3 is appropriate.

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

Purpose4/5

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

The description clearly states the action ('restore real .env values from the vault') and the resource ('.env values'). It distinguishes from siblings by mentioning 'reverses the sandbox operation', implicitly linking to sandbox_env. However, it doesn't explicitly name the sibling tool.

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

Usage Guidelines2/5

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

No explicit guidance on when to use this tool versus alternatives. It only states it reverses the sandbox operation, but does not mention prerequisites (e.g., must have sandboxed first) or 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.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

  1. 1 tool updatev0.2.0
    • Addedaudit_log
  2. 6 tool updatesv0.1.4
    • First observeddelete_secret
    • First observedlist_secrets
    • First observedresolve_secret
    • First observedsandbox_env
    • First observedstore_secret
    • First observedunsandbox_env

TDQS

A3.7/5.0
Disambiguation5/5

Each tool has a clearly distinct purpose: audit logging, listing, storing, deleting, resolving secrets, and sandboxing .env files. No overlap or ambiguity.

Naming Consistency5/5

All tool names use consistent snake_case and follow a clear verb_noun pattern (e.g., list_secrets, store_secret, resolve_secret).

Tool Count5/5

7 tools is well-scoped for a secret management server, covering CRUD, audit, and sandbox operations without being excessive.

Completeness4/5

Covers core secret lifecycle (create, read, list, delete) and audit, but lacks an explicit update tool; users must delete and recreate.

Maintenance

ActivityInactive
ResponsivenessSyncing

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

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

Related MCP Connectors

Related MCP Servers

  • A
    license
    Not graded
    quality
    D
    maintenance
    Encrypted credential vault with a 21-tool MCP server. Store and manage LLM API keys, service API keys, and OAuth credentials — then let your AI agent list, reveal, rotate, rename, pause, and proxy calls through them.
    MIT
  • A
    license
    A
    quality
    D
    maintenance
    Local AES-256-GCM encrypted vault for AI agents. Resolve {{PLACEHOLDER}} secrets in prompts at runtime — LLMs never see real API keys. Argon2id key derivation, zero cloud.
    2
    84
    2
    MIT
  • A
    license
    Not graded
    quality
    D
    maintenance
    Enables AI agents to securely manage API keys and secrets via the MCP protocol, with encrypted storage at rest and a simple CLI and Python SDK.
    MIT
  • A
    license
    Not graded
    quality
    C
    maintenance
    Encrypts and stores API keys and environment variables locally, providing them to AI agents via MCP with tools for listing, describing, getting secrets, and running commands with secret values redacted.
    2
    MIT

Latest Blog Posts

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/aarifmms/keyblind'

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