Agentvalet

by AgentValet

1 stars

385 downloads

Not rated

GitHub

About

IGA for AI agents. IETF AIMS-compliant identity, credential governance & MCP proxy. SPIFFE · RFC 7591 · AuthZEN · CIBA. npx @agentvalet/register

Details

Author: AgentValet
GitHub stars: 1
Downloads: 385
Categories: Other, Security

- Per-agent RS256 cryptographic identity with SPIFFE-format URIs
- Deny-by-default scopes and granular per‑agent‑per‑platform‑per‑action grants
- Human‑in‑the‑loop approval for destructive or financial scopes
- Immutable, append‑only audit log that is filterable and exportable
- Three‑strike circuit breaker that auto‑suspends misbehaving agents
- Native MCP server plus one‑command CLI (@agentvalet/register)
- Self‑hostable (PostgreSQL) and standards‑aligned (SPIFFE, RFC 7591, AuthZEN 1.0, IETF AIMS)

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Agentvalet

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "agentvalet": {
            "agentvalet": {
                "command": "npx",
                "args": [
                    "-y",
                    "@agentvalet/mcp-server"
                ],
                "env": {
                    "AGENT_ID": "agt_...",
                    "OWNER_ID": "...",
                    "PROXY_URL": "https://api.agentvalet.ai",
                    "AGENT_PRIVATE_KEY_PATH": "/path/to/agent.key"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "agentvalet": {
            "agentvalet": {
                "command": "npx",
                "args": [
                    "-y",
                    "@agentvalet/mcp-server"
                ],
                "env": {
                    "AGENT_ID": "agt_...",
                    "OWNER_ID": "...",
                    "PROXY_URL": "https://api.agentvalet.ai",
                    "AGENT_PRIVATE_KEY_PATH": "/path/to/agent.key"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "agentvalet": {
            "agentvalet": {
                "command": "npx",
                "args": [
                    "-y",
                    "@agentvalet/mcp-server"
                ],
                "env": {
                    "AGENT_ID": "agt_...",
                    "OWNER_ID": "...",
                    "PROXY_URL": "https://api.agentvalet.ai",
                    "AGENT_PRIVATE_KEY_PATH": "/path/to/agent.key"
                }
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "agentvalet": {
            "agentvalet": {
                "command": "npx",
                "args": [
                    "-y",
                    "@agentvalet/mcp-server"
                ],
                "env": {
                    "AGENT_ID": "agt_...",
                    "OWNER_ID": "...",
                    "PROXY_URL": "https://api.agentvalet.ai",
                    "AGENT_PRIVATE_KEY_PATH": "/path/to/agent.key"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "agentvalet": {
            "agentvalet": {
                "command": "npx",
                "args": [
                    "-y",
                    "@agentvalet/mcp-server"
                ],
                "env": {
                    "AGENT_ID": "agt_...",
                    "OWNER_ID": "...",
                    "PROXY_URL": "https://api.agentvalet.ai",
                    "AGENT_PRIVATE_KEY_PATH": "/path/to/agent.key"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "agentvalet": {
            "agentvalet": {
                "command": "npx",
                "args": [
                    "-y",
                    "@agentvalet/mcp-server"
                ],
                "env": {
                    "AGENT_ID": "agt_...",
                    "OWNER_ID": "...",
                    "PROXY_URL": "https://api.agentvalet.ai",
                    "AGENT_PRIVATE_KEY_PATH": "/path/to/agent.key"
                }
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "agentvalet": {
            "agentvalet": {
                "command": "npx",
                "args": [
                    "-y",
                    "@agentvalet/mcp-server"
                ],
                "env": {
                    "AGENT_ID": "agt_...",
                    "OWNER_ID": "...",
                    "PROXY_URL": "https://api.agentvalet.ai",
                    "AGENT_PRIVATE_KEY_PATH": "/path/to/agent.key"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "agentvalet": {
            "agentvalet": {
                "command": "npx",
                "args": [
                    "-y",
                    "@agentvalet/mcp-server"
                ],
                "env": {
                    "AGENT_ID": "agt_...",
                    "OWNER_ID": "...",
                    "PROXY_URL": "https://api.agentvalet.ai",
                    "AGENT_PRIVATE_KEY_PATH": "/path/to/agent.key"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "agentvalet": {
            "agentvalet": {
                "command": "npx",
                "args": [
                    "-y",
                    "@agentvalet/mcp-server"
                ],
                "env": {
                    "AGENT_ID": "agt_...",
                    "OWNER_ID": "...",
                    "PROXY_URL": "https://api.agentvalet.ai",
                    "AGENT_PRIVATE_KEY_PATH": "/path/to/agent.key"
                }
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "agentvalet": {
            "agentvalet": {
                "command": "npx",
                "args": [
                    "-y",
                    "@agentvalet/mcp-server"
                ],
                "env": {
                    "AGENT_ID": "agt_...",
                    "OWNER_ID": "...",
                    "PROXY_URL": "https://api.agentvalet.ai",
                    "AGENT_PRIVATE_KEY_PATH": "/path/to/agent.key"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "agentvalet": {
            "agentvalet": {
                "command": "npx",
                "args": [
                    "-y",
                    "@agentvalet/mcp-server"
                ],
                "env": {
                    "AGENT_ID": "agt_...",
                    "OWNER_ID": "...",
                    "PROXY_URL": "https://api.agentvalet.ai",
                    "AGENT_PRIVATE_KEY_PATH": "/path/to/agent.key"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "agentvalet": {
            "agentvalet": {
                "command": "npx",
                "args": [
                    "-y",
                    "@agentvalet/mcp-server"
                ],
                "env": {
                    "AGENT_ID": "agt_...",
                    "OWNER_ID": "...",
                    "PROXY_URL": "https://api.agentvalet.ai",
                    "AGENT_PRIVATE_KEY_PATH": "/path/to/agent.key"
                }
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "agentvalet": {
            "agentvalet": {
                "command": "npx",
                "args": [
                    "-y",
                    "@agentvalet/mcp-server"
                ],
                "env": {
                    "AGENT_ID": "agt_...",
                    "OWNER_ID": "...",
                    "PROXY_URL": "https://api.agentvalet.ai",
                    "AGENT_PRIVATE_KEY_PATH": "/path/to/agent.key"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "agentvalet": {
            "agentvalet": {
                "command": "npx",
                "args": [
                    "-y",
                    "@agentvalet/mcp-server"
                ],
                "env": {
                    "AGENT_ID": "agt_...",
                    "OWNER_ID": "...",
                    "PROXY_URL": "https://api.agentvalet.ai",
                    "AGENT_PRIVATE_KEY_PATH": "/path/to/agent.key"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "agentvalet": {
            "agentvalet": {
                "command": "npx",
                "args": [
                    "-y",
                    "@agentvalet/mcp-server"
                ],
                "env": {
                    "AGENT_ID": "agt_...",
                    "OWNER_ID": "...",
                    "PROXY_URL": "https://api.agentvalet.ai",
                    "AGENT_PRIVATE_KEY_PATH": "/path/to/agent.key"
                }
            }
        }
    }
}

From the repository

Run npx @agentvalet/register to generate an RS256 keypair, register the agent, and wire up the configuration. Alternatively, manually add the MCP server to your client’s config with environment variables AGENT_ID, OWNER_ID, PROXY_URL, and AGENT_PRIVATE_KEY_PATH. The server exposes seven tools: list_platforms, use_platform, authzen_evaluate, agent_register, agent_status, list_my_pending_actions, and report_self_diagnostic.

`list_platforms`

list_platforms: List the platforms and permission scopes this agent has access to. Input: None. Returns: { platforms: [{ platformId, platformName, scopes, requireApproval, connections? }], version: "<hex>" }. A platform includes `connections` only when it has 2+ usable accounts; pass the chosen connection_id to use_platform (omit for the default). Version: a deterministic hash over the effective spec — it changes whenever the platform set, the scopes, or the requireApproval flags change. Compare it against the `Current permissions version` stamped on this description: if they differ, your cached result is stale and you must call list_platforms again before trusting it. Auth: Bearer JWT.

`use_platform`

use_platform: Call an external platform API (Airtable, GitHub, Slack, Metabase, etc.) through the AgentValet proxy. Input: platform (string), endpoint (string), method (GET|POST|PUT|PATCH|DELETE), scope (string), body (object, optional — JSON request body for POST/PUT/PATCH/DELETE), reason (string, optional — why you are making this call; shown to the human approver when the action is gated). Returns: upstream API response body. May take up to 50 seconds when the action requires owner approval — the call will block while we wait, then return the approved result transparently. If approval doesn't land in time, returns a `pending_approval` envelope and the action runs asynchronously; the user is notified when it completes. Auth: Bearer JWT. Note: legacy clients passing `data` instead of `body` are still accepted for backwards compatibility, but `body` is the canonical name.

`agent_register`

agent_register: Self-register this agent with an owner. No auth required. Input: owner_id (string), agent_name (string), requested_scopes (array of {platformId, scopes}). Returns: registration_token, poll_url, client_id, scope, expires_in. Auth: None.

`agent_status`

agent_status: Poll registration status using the token from agent_register. Input: token (string, required). Returns: status ("pending_approval"|"approved"|"rejected"), agent_id (if approved), mcp_config (if approved). Auth: None.

`authzen_evaluate`

authzen_evaluate: Evaluate whether this agent has access to a specific platform scope. Call this BEFORE use_platform when you want to pre-check without making the upstream call. Input: platform_id (string), scope (string). Returns: decision (boolean), reason ("approved"|"denied"|"revoked"|"scope_not_granted"). Auth: Bearer agent JWT (sent automatically by this MCP server).

`report_self_diagnostic`

report_self_diagnostic: Lodge a self-report (error/warning/info) with the AgentValet owner. Use after a use_platform error returns a report_hint, OR proactively when you encounter a problem the user should know about. Input: severity (debug|info|warn|error|critical), message (string, required, max 4096 bytes), code (string, optional, max 128 chars), platform (string, optional), endpoint (string, optional), correlation_id (uuid string, optional — copy from the failing call's report_hint to stitch this report to the broker-side audit row), context (object, optional, JSON-serialised must be < 16 KiB). Returns: { id, received_at } on success. Auth: Bearer agent JWT (sent automatically).

`list_my_pending_actions`

list_my_pending_actions: Returns this agent's currently-pending approval requests AND any that completed in the last 24 hours. Use this at session start when the user mentions an earlier action, or when use_platform's long-poll timed out and the user comes back asking what happened. Input: None. Returns: { pending: [{approval_id, platform_id, scope, created_at, expires_at}], recently_completed: [{approval_id, platform_id, scope, status, executed_at, result_summary, execution_error}] }. Auth: Bearer agent JWT (sent automatically).

`request_platform_access`

request_platform_access: Ask an org admin to grant this agent access to a platform it is currently blocked from. Call this when use_platform returns an access-denied error. Input: platform (string, required), scope (string, optional — the specific scope you need), reason (string, optional — why you need it). The call waits up to ~50s for an admin decision. Returns: { status: "approved"|"pending"|"denied", message }. On "approved", retry your original use_platform call. On "pending", the request is queued; retry later. Auth: Bearer agent JWT (sent automatically).

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "agentvalet": {
            "agentvalet": {
                "command": "npx",
                "args": [
                    "-y",
                    "@agentvalet/mcp-server"
                ],
                "env": {
                    "AGENT_ID": "agt_...",
                    "OWNER_ID": "...",
                    "PROXY_URL": "https://api.agentvalet.ai",
                    "AGENT_PRIVATE_KEY_PATH": "/path/to/agent.key"
                }
            }
        }
    }
}

McpServers

{
    "agentvalet": {
        "command": "npx",
        "args": [
            "-y",
            "@agentvalet/mcp-server"
        ],
        "env": {
            "AGENT_ID": "agt_...",
            "OWNER_ID": "...",
            "PROXY_URL": "https://api.agentvalet.ai",
            "AGENT_PRIVATE_KEY_PATH": "/path/to/agent.key"
        }
    }
}

AgentValet

Identity and credential governance broker for AI agents and MCP servers. It gives every agent its own cryptographic identity, scoped and short-lived credentials per platform, human approval gates on the actions that matter, and an immutable audit log of everything it did.

Open core. This repo holds the open-source MIT-licensed client surface: the MCP server, the CLI, the Claude Desktop bundle, and the runtime adapters. The managed proxy runs the credential vault, the policy engine, and the audit store. A self-host reference for the proxy is on the roadmap.

Live at agentvalet.ai. Docs at docs.agentvalet.ai.

Quickstart

npx @agentvalet/register

That generates an RS256 keypair for your agent, registers it, and wires up the config. The private key never leaves your machine. From then on your agent signs a short-lived JWT per request and calls platforms through the AgentValet proxy. Approve the agent in the dashboard, grant it scopes, and you are running.

Use as an MCP server

npx @agentvalet/register writes this block into your client's MCP config for you. To wire it up by hand — in Claude Desktop, Claude Code, Cursor, or any MCP-compatible client — add:

{
  "mcpServers": {
    "agentvalet": {
      "command": "npx",
      "args": ["-y", "@agentvalet/mcp-server"],
      "env": {
        "AGENT_ID": "agt_your_agent_id",
        "OWNER_ID": "your_owner_id",
        "PROXY_URL": "https://api.agentvalet.ai",
        "AGENT_PRIVATE_KEY_PATH": "~/.agentvalet/agent.key"
      }
    }
  }
}

The server exposes seven tools: list_platforms, use_platform, authzen_evaluate, agent_register, agent_status, list_my_pending_actions, and report_self_diagnostic. The private key is read from AGENT_PRIVATE_KEY_PATH and never leaves your machine; every platform call goes through the proxy with scope checks, audit logging, and human approval on the actions that matter.

The problem: credential inheritance

Credential inheritance is what happens when an AI agent runs on your credentials instead of its own. The moment a token lands in .mcp.json or an environment variable, every agent in that project inherits the full reach of that token. It can do anything you can do, on every platform the token touches, and nothing records which agent did what.

| House key agent (today's default) | Valet key agent (AgentValet) |
|-----------------------------------|------------------------------|
| Holds your real token | Holds a short-lived signed token, never your credential |
| Full scope on every platform the token reaches | Scoped to exactly the actions you granted |
| A leaked config leaks everything | A leaked config leaks nothing reusable |
| No record of which agent did what | Every call attributed to one agent identity |
| Revoking means rotating the token everywhere | One revoke, instant, no rotation |

How it works

Agent (holds its RS256 private key)
    |
    |  signs a 60-second JWT per request
    v
+-------------------------------------------+
|              AgentValet proxy             |
|  1. verify JWT signature                  |
|  2. check scope grant (deny by default)   |
|  3. scan request for leaked secrets       |
|  4. AuthZEN policy evaluation             |
|  5. human approval gate, if required      |
|  6. inject real credential in memory      |---> SaaS platform
|  7. append-only audit log entry           |
+-------------------------------------------+
    |
    v
Dashboard: approve registrations, manage scopes, review the audit log, monitor usage
MCP server: exposes AgentValet as tools for Claude and any MCP-compatible agent

Credentials use envelope encryption: a unique AES-256 data key per credential, wrapped by a master key held in a Key Vault HSM, decrypted in memory only at call time and never written to a log.

Features

- Per-agent RS256 cryptographic identity, SPIFFE-format URIs, 60-second signed JWTs
- Deny-by-default scopes, granular per-agent-per-platform-per-action grants
- Human-in-the-loop approval for destructive or financial scopes, one-click magic-link
- Immutable, append-only audit log, filterable and exportable
- Three-strike circuit breaker that auto-suspends a misbehaving agent
- Native MCP server plus a one-command CLI
- Self-hostable: PostgreSQL-backed, runs in your own infrastructure
- Standards-aligned: SPIFFE, RFC 7591 Dynamic Client Registration, AuthZEN 1.0, IETF AIMS

How AgentValet compares

Honest framing. These are strong tools that reached agent governance from an adjacent starting point.

| | AgentValet | Aembit | Akeyless | Infisical Agent Vault |
|---|---|---|---|---|
| Starting point | Agent-first identity and governance | Workload identity | Secrets management | Secrets vault |
| Where it sits | Identity-layer credential broker | Edge proxy near workloads | Gateway in your network | Network-layer forwarding proxy |
| Onboarding | Self-serve, under 5 minutes | Enterprise sales-led | Enterprise sales-led | Self-host or cloud |
| Open source | Open core, MIT | No | No | Core open source |
| Standout strength | AIMS-aligned, approval gates, audit, cheap entry | Attestation-based identity | Distributed fragments cryptography | Network-level interception |

\ The client surface (MCP server, CLI, bundle, adapters) is MIT in this repo. The proxy is a managed service today, with a self-host reference on the roadmap.

If you already run Aembit or Akeyless at enterprise scale, AgentValet is not trying to replace your identity provider. If you are a developer or small team shipping agents this week, AgentValet is built for you.

Roadmap and known limitations

Building in public, so the rough edges are listed here rather than discovered.

Known limitations today
- The SSE stream for approval status can close prematurely on long waits. Reconnect logic is planned.
- CLI rate limiting is rudimentary.
- There is no clear or delete UI yet for expired pending registrations.

On the roadmap
- Self-host reference for the proxy (the open client surface already runs anywhere)
- SIEM export for the audit log (Enterprise)
- Multi-region self-hosting guides
- Custom integrations UI (today these are requested through the roadmap system)
- PII handling Phase 2: detection at the broker layer

What is open and what is managed

Open source in this repo, MIT licensed: the MCP server, the @agentvalet/register CLI, the Claude Desktop bundle, the runtime adapters, and @agentvalet/mcp-broker.

The two MCP packages are mirror images of each other: @agentvalet/mcp-server lets an agent call platforms through the AgentValet proxy, whereas @agentvalet/mcp-broker lets you embed AgentValet policy and credential enforcement inside your own MCP server, with a genuinely useful local mode and zero required account.

Managed service today: the proxy that holds the credential vault, runs the policy engine, and writes the audit log. A self-host reference for the proxy is on the roadmap. See CONTRIBUTING.md for local development of the open packages.

Security

Found a vulnerability? Please report it privately, see SECURITY.md. Do not open a public issue for security reports.

License

MIT. See LICENSE.

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

list_platforms

use_platform

agent_register

agent_status

authzen_evaluate

report_self_diagnostic

list_my_pending_actions

request_platform_access

Claude Desktop / Cursor

McpServers

AgentValet

Quickstart

Use as an MCP server

The problem: credential inheritance

How it works

Features

How AgentValet compares

Roadmap and known limitations

What is open and what is managed

Security

License

Install

More like this

Sequential Thinking

Filesystem

EverArt

Google Drive

Reactive Resume

FastMCP v2 🚀

`list_platforms`

`use_platform`

`agent_register`

`agent_status`

`authzen_evaluate`

`report_self_diagnostic`

`list_my_pending_actions`

`request_platform_access`