Bitwarden Agent Access: You Don't Have to Give AI Agents Your Whole Vault Anymore
A new open protocol from Bitwarden lets you approve credential requests from your own device. The design is good. Which command you let the agent run decides whether the password ends up in a log.
Every useful agent eventually hits a login screen. A database, a staging dashboard, a deploy script that wants a token. And the standard answers are all a little embarrassing: a .env file the agent can read in full, a key pasted into the chat window, or a long-lived token with far more access than the task needs.
Password managers have been watching this happen. Bitwarden's answer is Agent Access, an open protocol, a command-line tool called aac and a software kit that lets an agent ask for one credential at a time while you approve requests from your own machine (one by one, unless you choose a short auto-approve window). It climbed GitHub's trending lists this week, and it's worth a look for a reason beyond the brand name.
The tool gives you two ways to hand over a secret. One prints the password where the agent, and every log it writes, can see it. The other passes it straight into a program the agent starts. In commands, that's aac connect versus aac run, and the README says to prefer the second for AI agents. Here's why that advice is right, and why it still leaves one door that only you can close.
What Agent Access does, in plain terms
Think of a bank's night deposit box, but in reverse. You keep the vault. The agent gets a slot it can ask through, one item at a time, and someone has to say yes before anything comes back.
The pieces, as the README describes them:
- Your side runs
aac listenon a trusted device. It connects to your Bitwarden vault through the Bitwarden command-line tool (bw), or to a built-in example provider that only knows a fakeexample.comlogin. - The agent's side runs
aac connectoraac runand asks for a credential by website domain or vault item ID. - Between them sits an end-to-end encrypted tunnel built on Noise, a well-known protocol for setting up encrypted channels. A relay server passes the encrypted traffic along. The example skill file lists the default relay as
wss://ap.lesspassword.dev, and the repo includes its own relay "for demo/development purposes."
You start by pairing. aac listen prints a short token like ABC-DEF-GHI, you give it to the agent's side once, and the session is cached in ~/.access-protocol/ so later requests don't need it again, per the skill file.
The part I liked: a human says yes
Reading the code at the v0.11.0 release, the listen side shows every request as a prompt with three keys: [y] approve [a] approve + auto-approve [n] deny (listen.rs). The auto-approve choice starts at 10 minutes and can be adjusted. The code caches that decision per requesting device and per exact query, so "github.com from this agent" doesn't silently cover "aws.amazon.com from this agent."
That is the right shape for agent credentials. The agent never browses your vault. It asks for one named thing, and you see the ask.
The protocol draft on main (newer than the v0.11.0 tag) is candid about what's missing. Its open items include a "purpose string" so the approval prompt could show something like "agent X accessing site Y for user task Z" (protocol-v0.md). Today you approve a domain, not a reason.
Two ways out of the vault
Here's where most people will go wrong, because the first example in the docs is the risky one.
aac connect fetches the credential and prints it as JSON:
aac connect --domain github.com --provider bitwarden --output json
# {"credential":{"password":"alligator5","username":"example",...},"success":true}
That's convenient for scripts. For an AI agent it means the password lands in the agent's context, the transcript, and any log or telemetry that records tool output. The agent read it, so the agent's provider saw it too.
aac run fetches the credential and passes it into a program as environment variables, the named values a process can read when it starts:
aac run --domain example.com --env PGPASSWORD=password --env PGUSER=username -- psql
The run command's source opens with the promise: "Secrets never touch stdout or disk." The agent sees psql's output, not the password. The README's own warning box says it plainly: for LLMs, "where possible use environment injection (e.g. aac run) to pass secrets to processes without exposing them in recorded context."
The door only you can close
aac run keeps the secret out of the record. It doesn't keep it out of reach.
The agent chooses the command after the --. The run code starts that program and lets it print to the screen like any other, which is the whole point for psql. It also means an agent that has been confused or prompt-injected (tricked by text hidden in a web page or file it read) could run something like aac run --domain example.com --env-all -- env, and the program it starts would happily print every variable it received. Nothing in the README or the run command I read prevents that. It's the nature of handing a value to a program someone else picks.
So the real controls are the ones around the tool:
- Your approval. You see each request. Use
[y], not[a], when you're not watching the session closely. - What's in the vault the agent can reach.
aac listenserves whatever the signed-inbwsession can see. - What the credential can do. A read-only database user leaks less than an admin.
That's the useful mental shift with this tool: the agent doesn't need to never see a secret; it needs to only ever reach secrets you'd survive leaking. Agent Access makes the "one at a time, with a yes" part easy. The scope part is still yours.
How it compares with what you probably do now
It helps to line this up against the usual setups, because the improvement is real even with the caveat above.
A .env file in the project. The agent can read every secret in it, any time, without asking. Nobody sees the read happen. If the agent pastes the file into a bug report, everything goes at once.
A key pasted into the chat. The secret sits in the conversation history for as long as that history exists, on your machine and at your model provider. It's also usually a long-lived key, because nobody wants to paste a new one every hour.
A cloud secrets manager with a service account. Much better, but the agent's identity can typically read any secret its role allows, and you set that role once, not per request.
Agent Access with aac run. The agent asks for one named item, you see the request, the secret travels encrypted, and it lands in a child process instead of the transcript. The weak spot is the child command, and you can see that command in the agent's own tool call before it runs.
That last point matters. With Agent Access, a leak needs a visible request you approved and a visible command that prints the value. With a .env file, it needs neither.
Put this into practice
You can try the whole flow safely in about fifteen minutes with the fake provider, before your real vault is involved.
1. Install. On an Apple Silicon Mac, from the README:
curl -L https://github.com/bitwarden/agent-access/releases/latest/download/aac-macos-aarch64.tar.gz | tar xz
sudo mv aac /usr/local/bin/
There are builds for Intel Macs, Linux x86_64 and Windows x86_64 too. latest resolves to v0.11.0 today; if you script this, pin that version so a future release doesn't change under you.
2. Start the listener with fake data. aac listen --provider example gives you a pairing token and a provider that only knows example.com.
3. Pair and fetch from a second terminal. aac connect --token <token> --domain example.com --output json. Watch the approval prompt appear on the listener and press y.
4. Try the safe path. aac run --domain example.com --env-all -- printenv AAC_USERNAME. You'll see the username printed, because you asked the child to print it. That's the lesson in one line: run protects the transcript only as long as the child command keeps quiet.
5. Move to your real vault with a dedicated account. Install the Bitwarden CLI, log it in to a vault that holds only what agents should ever touch, and run plain aac listen. Keep your personal vault out of that session.
6. Teach your agent the rule. If you use the bundled skill file, edit its example to use aac run for anything that has a program to receive it, and keep aac connect for the rare case where the agent must type a password into a browser itself.
Honest limitations
This is early software and says so. The README calls it an "early preview stage" where "APIs and protocols are subject to change."
The latest tagged release, v0.11.0, dates from March 21, 2026, and the newest commit on main when I cloned it was from August 20. It's a small project by GitHub numbers: a few hundred stars, with shields.io reporting about 580 on November 19 and GitHub's rendered page showing fewer. It's Apache-2.0 licensed. Expect rough edges, and pin the version you test.
Pairing with the short token ("rendezvous" mode, where the relay helps the two sides find each other) trusts the relay more than you might expect. The protocol draft warns that in that mode a malicious relay could sit in the middle and read traffic (a man-in-the-middle attack) unless both sides compare a short handshake fingerprint, a code each side displays, over some other channel. The skill file lists a --verify-fingerprint flag for exactly that. The longer pre-shared-key (PSK) tokens, which carry a long random secret both sides already hold, avoid this. The same draft notes the relay can see who is connected and the size and timing of messages, though not their contents.
Your trusted device has to be online. The protocol lists relay buffering as an open item because "the relay requires clients to be online."
There is no reason shown in the approval prompt yet, as covered above, and no way for the agent to discover which fields a vault item supports.
And the leak path through the child command is real. It isn't a bug in Agent Access; it's what passing a value to a program means. But the marketing line ("without exposing their entire vault") is about the vault, not the item, and it's worth reading precisely.
Where this leaves you
The pattern Agent Access sets is the one agent credentials should follow everywhere: one item, on request, with a person or a policy saying yes, through a channel nobody in the middle can read. Bitwarden built it as an open protocol so other password managers can answer the same requests, which is the part to watch.
For now, the practical rule is short. Pair it with a vault built for agents, approve requests one at a time while you're learning how your agent behaves, and reach for aac run before aac connect. Then ask the question the tool can't answer for you: if this credential showed up in a log tomorrow, how bad would that be?
Sources: bitwarden/agent-access README at v0.11.0 · agent-access skill file · protocol-v0.md, main at 5127562 · listen.rs approval prompt · run.rs · Bitwarden CLI · shields.io star count. Reviewed at tag v0.11.0 (March 21, 2026) and main commit 5127562, November 19, 2026.