AgentValet vs AWS Bedrock AgentCore Identity

Amazon Bedrock AgentCore Identity is AWS’s identity and credential service for AI agents. It and AgentValet both give agents an identity and keep credentials out of config files. The difference that matters is where the token ends up when the agent makes a call, and how much of AWS you want around it.

Updated

The short answer

Pick AgentValet if you want the platform credential kept out of agent code entirely, each agent signing its own requests, and a person able to approve a risky action before it runs.

Pick AgentCore Identity if you build on AWS, especially on AgentCore Runtime or Gateway where it adds no charge, and you want agent identity, token storage and IAM in the account you already govern.

Two approaches, in plain words

What AgentCore Identity is

AgentCore Identity is part of Amazon Bedrock AgentCore. Each agent gets a workload identity with its own ARN in a central directory, and a token vault stores OAuth tokens, OAuth client credentials and API keys, encrypted with AWS KMS keys that AWS or you manage. Credentials can only be retrieved by an agent presenting proof of its workload identity.

Outbound access runs through credential providers, with built-in OAuth providers for Google, GitHub, Slack, Salesforce and Atlassian, and both machine-to-machine and user-delegated flows. In agent code, an SDK decorator such as @requires_access_token fetches the token, runs the user consent flow when needed, and passes the access token into your function. Through AgentCore Gateway, the gateway injects the credential for each tool instead.

What AgentValet is

AgentValet is a credential broker for AI agents. The agent asks the broker to make the call, and the broker checks that agent’s grant for the platform and action, pauses for a person when a rule says so, and attaches the credential in memory.

Agent code never receives the token. AgentValet is a managed service hosted in Australia.

The question that separates them

Does the token reach your agent’s code?

With the AgentCore SDK it does. The decorator hands the access token to the decorated function, and from there it sits in the agent process like any other variable. AWS’s guidance is to apply least privilege and audit access, which is a reasonable model when you trust the code that runs. AgentCore Gateway changes the picture for the tools behind it, because the gateway injects the credential per tool.

AgentValet keeps the credential at the broker on every call, with or without a gateway, so the agent process never holds a platform token.

AgentCore Identity with the SDK
  1. Agent code
  2. Identity checks the workload identity and IAM
  3. Access token passed into the function (the key sits with the agent)
  4. Agent calls the API
  5. Real service

Through AgentCore Gateway the gateway injects the credential per tool instead, and the agent never handles it.

AgentValet enforces at the platform call
  1. Your agent
  2. Broker checks identity, grant and approval
  3. Credential attached in memory
  4. SaaS API or MCP server

The agent holds no platform key, and a risky call can wait for a person before it runs.

The standard comparison

One line per cell. Open the detail underneath for the longer version.

AgentValet compared with AgentCore Identity
AgentValetAgentCore Identity
Per-agent identityEach agent gets its own RS256 signing keypair and signs every request.Each agent gets a workload identity with its own ARN in a central directory.
Credential exposure to the agentThe agent never holds or sees the credential.With the SDK the access token is passed into agent code; through Gateway, the gateway injects it per tool.
Token lifetimeEach request carries a short-lived token signed by the agent; upstream credentials stay in the broker.Access tokens last as long as the provider issues them, and stored refresh tokens are used to get new ones.
Scoping granularityPer agent, per platform and per action, deny by default.OAuth scopes per credential provider, plus IAM policies on the token vault and workload identities.
Human approvalRisky actions pause at the broker until a person approves them.User consent through the OAuth flow, reused until the tokens lapse; no per-action approval is described.
Audit evidenceEvery decision is logged with the policy, version, result and reason, and exports as CSV or JSON.CloudWatch metrics and spans for each token and key fetch, plus application logs to CloudWatch Logs, S3 or Firehose.
MCP supportA native MCP server, and it brokers calls to upstream MCP servers as an OAuth client.Supports RFC 8707 resource indicators for MCP, and AgentCore Gateway turns APIs and Lambda functions into MCP tools.
Self-host optionNo. It is a managed service hosted in Australia.No: it’s a managed AWS service, though the agents using it can run outside AWS.
Open sourceThe parts that run on your machines (MCP server, CLI, SDKs and adapters) are MIT licensed. The broker is not.The AgentCore SDKs and CLI are Apache 2.0 licensed; the service itself is run by AWS.
Setup timeOne command, npx @agentvalet/register, registers an agent.The first tutorial creates a Cognito user pool, a credential provider, an IAM policy and a Runtime deployment.
Starting priceFree plan, with paid plans from US$99 a month.No extra charge through AgentCore Runtime or Gateway; otherwise US$0.010 per 1,000 token or API key requests.
The detail behind 8 of these rows
Per-agent identity

AgentValet: Every agent publishes an identity document and key set, so each call is attributable to one agent. Child agents can be issued their own identities with scopes cut down to a subset of the parent’s.

AgentCore Identity: AgentCore Runtime creates the workload identity when you deploy an agent, and agents running elsewhere can be given one too. The ARN path lets administrators apply policies to groups of agents.

Credential exposure to the agent

AgentValet: Each credential is envelope-encrypted and decrypted in memory only for the call it serves. It is never logged or returned to the agent.

AgentCore Identity: At rest, tokens and keys sit in the token vault, encrypted with AWS KMS keys, and each retrieval is validated on its own, even from callers in the same trust domain.

Token lifetime

AgentCore Identity: AWS notes that refresh tokens are often valid for around 30 days against 1 to 2 hours for a typical access token, and that AgentCore can’t detect a token revoked on the provider’s side.

Scoping granularity

AgentValet: The method and endpoint of each call are matched against the scope granted to that agent before any credential is decrypted.

AgentCore Identity: AgentCore Gateway has its own fine-grained access control, and AgentCore Policy is a separate service billed per authorisation request.

Human approval

AgentValet: Approve with a passkey, an email link or a mobile push. The approval is recorded with the action it released.

AgentCore Identity: AWS provides a consent portal and session binding so the signed-in user who started a flow is the one who completes it.

Audit evidence

AgentValet: The log is append-only and policy-stamped, and each decision carries a signed receipt.

AgentCore Identity: Spans and logs need observability turned on for each identity resource. AWS recommends CloudTrail for API and user activity logging.

Setup time

AgentCore Identity: AWS says the deploy step takes about 2 to 3 minutes. The tutorial needs Python 3.10 or later, uv, the AWS CLI, jq and Node.js 20 or later.

Starting price

AgentCore Identity: Charges apply only to requests for non-AWS resources, with no minimum fee. New AWS customers get up to US$200 in Free Tier credits.

Where AgentCore Identity genuinely wins

If your agents already live on AWS, AgentCore Identity is hard to beat on fit. Identity, the token vault, IAM, KMS keys you control and observability all sit in the account you already govern, and through Runtime or Gateway it costs nothing extra. The SDK takes the OAuth consent flow, refresh tokens and expiry off your hands, which is fiddly work done well.

It’s also the fuller product for user-delegated access: inbound JWT authorisers, a consent portal, connections to private identity providers and per-user session binding come with it.

Where AgentValet wins

AgentValet keeps the token out of the agent on every call, whether or not a gateway is involved. Grants are per agent, per platform and per action and are checked before any credential is decrypted, and a risky action can wait for a person to approve it with a passkey, an email link or a push notification.

Every decision is logged with the policy, version, result and reason and carries a signed receipt. It needs no AWS account, and one command registers an agent.

They can work together. Keep AgentCore Runtime for hosting agents on AWS, and route the platform calls that need per-action grants or a person’s approval through AgentValet.

The first step, side by side

Each command is the documented starting point for that product. AgentCore Identity’s comes from AWS’s “Build your first authenticated agent” tutorial.

AgentValet
npx @agentvalet/register
AgentCore Identity (from its first tutorial)
pip install bedrock-agentcore boto3 strands-agents pyjwt

Which one fits

Choose AgentCore Identity if

  • Your agents run on AWS, ideally on AgentCore Runtime or Gateway.
  • You want agent identity managed with IAM and KMS alongside the rest of your account.
  • Your agents mainly act for signed-in users through OAuth consent.

Choose AgentValet if

  • You don’t want platform tokens inside agent code at all.
  • You want a person to approve individual risky actions before they run.
  • Your agents aren’t on AWS, or you don’t want their access tied to it.

Run both if

  • You host agents on AgentCore Runtime and want a broker with approvals in front of their SaaS calls.

Govern one agent first.

Register an agent on the free plan with npx @agentvalet/register, grant it one scope, then try a call outside it. You’ll see the refusal, and the audit row it leaves behind.

npx @agentvalet/register