aarifmms/keyblind
The Keyblind server enables AI agents to securely manage sensitive information by encrypting, storing, resolving, and sandboxing secrets — ensuring plaintext values are never exposed in LLM conversation transcripts.
resolve_secret: Retrieve and decrypt a stored secret by name (e.g.,OPENAI_API_KEY,DATABASE_URL) from the configured backend (local vault, 1Password, Bitwarden, or environment variables) — the value is never visible in the conversation transcript.store_secret: Encrypt and store a new secret in the vault using AES-256-GCM encryption.list_secrets: List all stored secret names without ever revealing their actual values.sandbox_env: Replace real.envvalues with deterministic fakes, backing up the real values to the encrypted vault so AI agents only see placeholder data.unsandbox_env: Restore the original real.envvalues from the vault, reversing a previous sandbox operation.delete_secret: Permanently remove a secret from the vault by name.
Keyblind — Blind AI to Your Keys
Encrypted secrets vault with MCP for AI agents. Secrets resolved at runtime, never leaked to LLM conversations.
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 plaintextQuick 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 listThat'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-mcpThis 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 startWith biometric gate (Touch ID required before secrets are resolved):
keyblind unlock # Authenticate first
claude mcp add keyblind -- keyblind start --biometricSession expires after 15 minutes. Requires Pro or Team license.
MCP Tools
Tool | Description |
| Resolve a secret at runtime (value hidden from transcript) |
| Encrypt and store a secret |
| List secret names (values never revealed) |
| Delete a secret |
| Replace |
| Restore real |
| View secret resolution audit trail |
| Generate a TOTP 2FA code for a stored config |
| Store a TOTP configuration from otpauth:// URI |
| List all stored TOTP configurations |
| Delete a TOTP configuration |
| Create encrypted, expiring share link for a secret |
| Receive and decrypt a shared secret |
| Check dead man's switch status |
| Reset dead man's switch timer |
| Check SSO/OIDC authentication status |
Web Dashboard
Manage your secrets from a browser at app.keyblind.dev. Start the HTTP server:
keyblind start --httpThen 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).
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 statusBackends
Keyblind supports multiple secret backends:
keyblind backends # List available backends
keyblind backend 1password # Switch to 1Password
keyblind backend bitwarden # Switch to BitwardenBackend | Read | Write | Requires |
local (default) | ✓ | ✓ | Nothing |
1password | ✓ | ✓ |
|
bitwarden | ✓ | — |
|
env | ✓ | — | Nothing |
aws | ✓ | ✓ |
|
gcp | ✓ | ✓ |
|
azure | ✓ | ✓ |
|
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 |
| — |
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/with0700permissionsDeterministic 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 scriptDevelopment
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 modeLicense
MIT
Available Tools
7 toolsaudit_logA
View the audit log of secret resolutions, stores, and deletes. Shows who accessed which secret and when.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of entries to return (default: 50) |
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | The name of the secret to delete |
TDQS
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.
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.
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.
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.
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.
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).
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | The name of the secret to resolve (e.g., OPENAI_API_KEY, DATABASE_URL) |
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| filePath | No | Path to the .env file. Defaults to .env in current directory. |
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | A unique name for the secret (e.g., OPENAI_API_KEY, DATABASE_URL) | |
| value | Yes | The secret value to encrypt and store |
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| filePath | No | Path to the .env file. Defaults to .env in current directory. |
TDQS
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.
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.
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.
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.
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.
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 tool update
v0.2.0- Added
audit_log
6 tool updates
v0.1.4- First observed
delete_secret - First observed
list_secrets - First observed
resolve_secret - First observed
sandbox_env - First observed
store_secret - First observed
unsandbox_env
TDQS
Each tool has a clearly distinct purpose: audit logging, listing, storing, deleting, resolving secrets, and sandboxing .env files. No overlap or ambiguity.
All tool names use consistent snake_case and follow a clear verb_noun pattern (e.g., list_secrets, store_secret, resolve_secret).
7 tools is well-scoped for a secret management server, covering CRUD, audit, and sandbox operations without being excessive.
Covers core secret lifecycle (create, read, list, delete) and audit, but lacks an explicit update tool; users must delete and recreate.
Maintenance
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
A secret store for AI agents: the agent never sees the plaintext.
Encrypted secret store and rotation for autonomous agent credentials
Secrets for developers and agents—secure context and workflows without exposing secret values.
Encrypted store for API keys and database URLs your code needs. Use them without reading them.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEncrypted 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
- AlicenseAqualityDmaintenanceLocal 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.2842MIT
- AlicenseNot gradedqualityDmaintenanceEnables 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
- AlicenseNot gradedqualityCmaintenanceEncrypts 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.2MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
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