keychains.dev

Product Introduction

1. Definition: Keychains.dev is a secure credential proxy designed for AI agent security. It operates as a server-side intermediary between AI agents and external APIs, dynamically injecting credentials while shielding raw secrets from agent access.
2. Core Value Proposition: It exists to eliminate credential leakage risks in AI workflows. By replacing hard-coded secrets with template variables (e.g., {{GITHUB_TOKEN}}) and handling injection server-side, it ensures prompt injection immunity while granting users granular permission control and audit trails.

Main Features

1. Server-Side Credential Injection:
   Replaces template variables (e.g., {{STRIPE_PRIVATE_KEY}}) with live credentials during API call execution. Uses TLS-encrypted server processing, ensuring secrets never reach the AI agent’s environment or context window. Compatible with curl via keychains curl command.
2. User Consent Workflow:
   Implements scoped permission approval via one-click user consent. Requires explicit user authorization for new API scopes, displaying requested actions transparently. Integrates OAuth 2.0 with PKCE and supports 11,000+ providers.
3. SSH Key Identity & Stateful Fingerprinting:
   Authenticates machines via SSH keypairs, eliminating passwords. Each request exchanges a cryptographic fingerprint; leaked keys are invalidated on first misuse.
4. Scoped Delegation for Sub-Agents:
   Enables least-privilege access for sub-agents. Offers two modes:
   • Scoped Delegate Tokens: Restrict sub-agents to specific APIs (e.g., only GitHub read access).
   • Blank Tokens: Require fresh user approval for all sub-agent actions.

Problems Solved

1. Pain Point: Credential leakage via prompt injection or context window exposure. Keychains.dev renders secrets invisible to agents, blocking exfiltration.
2. Target Audience:
   • AI Agent Developers building tools with API integrations.
   • Enterprise Security Teams managing agent permissions.
   • DevOps Engineers automating credential rotation.
3. Use Cases:
   • An agent accessing GitHub API without exposing tokens in code.
   • Delegating Stripe payment processing to a sub-agent with restricted permissions.
   • Auditing all OpenAI API calls made by agents via the dashboard.

Unique Advantages

1. Differentiation vs. Secrets Managers (Vault, Doppler):
   Secrets managers protect credentials at rest; Keychains.dev secures them at runtime during agent-API interactions. Adds user consent layers and agent-specific audit trails.
2. Differentiation vs. API Gateways (Kong, Apigee):
   Gateways manage server-to-server traffic. Keychains.dev specializes in agent-to-API traffic with SSH machine identity and sub-agent delegation.
3. Key Innovation:
   Stateful fingerprinting combined with SSH-based authentication creates a zero-trust architecture. Credentials are dynamically bound to ephemeral sessions, invalidating compromised keys instantly.

Frequently Asked Questions (FAQ)

1. How does Keychains.dev prevent prompt injection attacks?
   Credentials are injected server-side, never exposed to the AI agent’s context. Agents only see template variables (e.g., {{API_KEY}}), making secrets immune to exfiltration via manipulated prompts.
2. Can Keychains.dev replace my existing secrets manager?
   No—it complements secrets managers. Store credentials in Vault/Doppler, while Keychains.dev handles runtime delegation, user consent, and agent-specific access control for those credentials.
3. What authentication methods does Keychains.dev support?
   It supports OAuth 2.0, API keys, Basic Auth, and custom headers. Automatic token refresh and PKCE enhance OAuth security for 11,000+ providers.
4. How quickly can I revoke an agent’s access?
   Permissions are revoked instantly via the dashboard. No grace periods; compromised keys are invalidated on next use via stateful fingerprint checks.
5. Is Keychains.dev suitable for multi-agent workflows?
   Yes. Use scoped delegate tokens to restrict sub-agents to specific APIs or blank tokens to force new user approvals for each task.