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.
- Agent code
- Identity checks the workload identity and IAM
- Access token passed into the function (the key sits with the agent)
- Agent calls the API
- Real service
Through AgentCore Gateway the gateway injects the credential per tool instead, and the agent never handles it.
- Your agent
- Broker checks identity, grant and approval
- Credential attached in memory
- 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 | AgentCore Identity | |
|---|---|---|
| Per-agent identity | Each 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 agent | The 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 lifetime | Each 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 granularity | Per 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 approval | Risky 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 evidence | Every 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 support | A 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 option | No. 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 source | The 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 time | One 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 price | Free 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.
npx @agentvalet/registerpip install bedrock-agentcore boto3 strands-agents pyjwtWhich 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.
Checked against the AgentCore Identity guide, AgentCore Identity features, Obtain OAuth 2.0 access token, Build your first authenticated agent, AgentCore identity observability data, Data protection in AgentCore Identity, the AgentCore Gateway guide, AgentCore pricing and the AgentCore Python SDK repository on 8 November 2026. If something has changed, report a correction and we’ll fix the page.
Sources
- the AgentCore Identity guide, accessed 8 November 2026
- AgentCore Identity features, accessed 8 November 2026
- Obtain OAuth 2.0 access token, accessed 8 November 2026
- Build your first authenticated agent, accessed 8 November 2026
- AgentCore identity observability data, accessed 8 November 2026
- Data protection in AgentCore Identity, accessed 8 November 2026
- the AgentCore Gateway guide, accessed 8 November 2026
- AgentCore pricing, accessed 8 November 2026
- the AgentCore Python SDK repository, accessed 8 November 2026
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