I just don’t think I agree with these designs at all. Everyone seems to be super laser focused on “not allowing their AI to have keys” when basically giving their AI direct access to what the keys enable, optionally adding a layer of ceremony in front where you tap “approve”. I’m looking at the alert that is shown there and I don’t see anything that makes me feel like it allows for an informed choice at the time of it popping up. So then, what’s the benefit?
As much as I wanted to say you’re wrong, you’re right. After reading TFA, the security boundary is not sound.
Wanting agents to act like you is wrong. You need to own that trust boundary. Build whatever tooling satisfies the contract that agents should have a “not”+<you> (or <you>+”-agent”) identity, and you actuate across that boundary explicitly.
For example, I have a second agent GitHub account that points at my human one. That allows me to write a trusted proxy that ACLs its identity tightly.
It cannot write to public repos ever. In the worst possible case, it externalizes to a private repo’s issue tracker. (Still has never happened in ~4 months)
Once you have this, you can let agents run free. But, it isn’t trivial to set up. Moreover, people don’t want to “do the work.”
All this assumes you abide by “never run untrusted agents on trusted hardware.”
Not to nitpick, but not only it is not wrong, it's like most of their value, and notably, it's also what the word "agent" means. My "agent" is someone (or something) that stands in for me, acts in my name and in my interests. There's little point in hiring (or building) an agent, if you're never going to let it act in your name in anything.
While I understand (and like, and use to the extent it's practical) of keeping agent and personal identities separate, letting the agents impersonate me is necessary, because commercial services abhore end-user automation, and purposefully do not support delegating any and all actions I can take to automation. It's a problem as old as time, predates "AI agents" by forever.
I would certainly prefer having separate credentials with permissions limited to what I want to allow the agent to do. However I have run into two problems with that.
The first, and bigger, issue is that some services either don't have have suffiently fine control over permissions, so in order to grant permission to do useful things, I also have to allow it to do dangerous things, or I don't have a way to create a more limited access token at all. I wish that it was more common to allow creating short-lived, limited accces personal access tokens for services.
The smaller issue is that sometimes I do want the agent to do something more risky with my approval, and provide me with sufficient context to make an informed decision. That can sort of be worked around though by telling it to just give me the command to run, then I can audit and run it myself.
This is exactly what https://keycontain.com is for! It wraps services to give ultra-fine-grained ACLs. They can be arbitrarily granular, and much more granular than the underlying API.
You can't magically add fine-grained access controls if a service doesn't have them.
This is adding an allow/deny popup on your phone to agent activity based on the interpretation of an LLM as to whether a given command is risky. That's a very different thing from actual access controls which really deny access to certain pathways, it's an attempt to plaster over both the lack of real access controls and the tendency of LLMs to bypass them.
If your agent is sufficiently motivated, it may choose to bypass these controls, by mistake or on purpose and you would never know, it would not be too hard to do.
Basically these designs are meant to protect the key from leaking i.e. if agent holds key, prompt injections can happen.
If agent never holds the key, then the risk profile changes.
But you're right that it's a different problem to what access the key has and that's a different problem usually solved by having narrower keys or etc.
disclaimer: I work on smolvm which does this at the networking layer and argued with myself on this too.
Sure, my view on this is more or less that often the setup that creates this kind of situation often allows the agent to effectively mint a new key anyway. For example, if you have my browser cookie or something I may not want my agent to leak this on the web, but if I use it to authenticate network requests to the service transparently the model can just go into the account page and change my password or something, then leak that. In general it is not safe to hand an agent access to a service which is designed for human interaction and assume that it was properly secured such that persistent, transferrable access is not something that can be generated.
As Cursor generously demonstrated for the whole world, long-lived credentials in LLM transcripts are an attack path.
Your transcript passes in plain-text through a chain of token and compute resellers. And you have no good way of knowing who those companies are and what type of "observability" they deploy.
I've been trying out tinfoil.sh recently which does give you a reasonably good way of knowing that your inference requests and responses are private, at least.
Of course, that doesn't mean the harness can't send credentials out to the public internet if the agent accidentally generates the wrong tool call.
The only case where i dont really care normally, is if Deepseek (their own host, not random company) can see my Deepseek keys. Apart from that, yes everything else is limited.
I usually just run Pi on my Raspberry PI 4b, and give it full os access. If it messes up the raspberry, i just reformat the SD card. It helps a lot for when i want to allow Pi to connect to an Android tablet to do UI testing etc as well as when working with microcontrollers.
>if agent holds key, prompt injections can happen.
I just rotate keys? And preload them with $$$. Following the same pragmatic advice that served me well trading crypto. Only gamble with what you are willing to lose.
I'm trying to address this w/ clank.talk: a self-discoverable scripting language for agents that replaces bash with a controlled sandbox environment and strives to be easy for humans to read:
I'm designing this for the student AI infrastructure here at Montana State, to avoid rolling out the current wild-west of local agents to our student body.
AppleScript lives again? ;) I think it's an interesting concept, but it's really hard to do right. There are a lot of things that require very careful accounting for even in such a design–I see that you are already blocking access to .git for example, since the agent can drop code there that makes safe-looking commands like git status unsafe. This is definitely something I've been looking at, as well as taint tracking, it's just really hard. Would be interested to see where you take it!
This is pretty cool! I can’t help but be really reminded of AppleScript. Was that an inspiration? I’ve always hated AS, but the primary reason was difficulty learning to write it. Readability, I realize, was actually a huge strength.
Truthfully, I tend to agree with you. I built lend mainly for the fact that I like ssh tools a lot (feel free to check my other projects) and have always wanted a way to run local commands without having to setup reverse ssh when I don't need to run sshd on my laptop.
For example, I store k8s credentials in 1pass and the cluster is only accessible via the network on my remote machine. I can grab the credentials from my laptop for the work I want to do on the remote, and never have to install 1pass on the remote machine.
Primary use case for lend wasn't agents when I started the project. It just was natural to add support for it after the fact.
What I do on my machine is I basically do not allow for local exec at all, except in some very specific scenarios where I carefully design the environment and make sure that it seems reasonable before handing it to the agent. For example, I have a specific profiling task that requires performance counters. Normally my agents can spin up VMs to run commands without my permission but in this case the counters are not exposed in the VM, which basically means that this must be run outside of the VM. In this case I have configured my setup to be that the agent is allowed to write to a binary at a specific location, and I approve of it running one command (in this case, without my supervision even) that is basically xctrace sandbox-exec [very restrictive handwritten profile] [this binary]. In this way, it can run code on my machine and get the metrics it wants, but it can't go "oh let me write a program to go and poke around the host machine" which it is prone to doing if you don't restrict it this way.
I guess what I have done is the exact opposite in that I have designed an environment for agents and then I am using it as a hammer to solve all my problems, I have had almost exactly the same problem as you and the the way I typically solve it is that I have persistent SSH connections already supported in my harness, and I can arbitrarily expose whatever I want into the "agent environment" (which doesn't necessarily need to even have an agent living there), and this environment is able to connect to the place that doesn't have the credentials, and then I can set up a way for reverse access to work with this tunnel.
It's more about ensuring that the keys have some modicum of responsible control. If you give naked keys to Claude in a chat session and use something like atuin threads in 6 months to sync agent sessions across machines you might have put your keys in a a few dozen files without realizing it.
In an ideal world, the key you give Claude isn't useful for more than X amount of time, and ideally not against the true endpoint at all.
Very true! Generally good to avoid giving Claude long lived keys
Buuuut if you do by accident, we’ve put a lot of work into making sure threads redacts as many secret patterns as possible, and update that list regularly
I keep seeing these various tools and asking myself the same question over and over.
Security professionals have been muzzled around AI usage and people that don’t really seem to know much about it are now writing the most ill conceived things about how to secure it.
Many security professionals are the source of most nonsensical concepts, because they're still approaching LLMs as if it was classical software that can be secured with enough hard, provable-in-abstract boundaries. This leads to nonsensical proposals (talking about W^X or "control/data plane separation", treating prompt injection as SQL injection, "if only more effort was spent on securing it"...), or proposals that defeat the entire value of LLMs ("lethal trifecta" framework is a breeding ground for such).
Truth is, LLMs are "little people on a chip" - they're valuable exactly because they do not have any kind of "control/data" separation (for fundamental reasons, reality doesn't have such separation either), and that lets them handle "people-shaped" tasks that are infeasible to script. Flip side, they're causing "people-shaped" problems and are vulnerable to same kinds of attacks people are, and need to be thought of accordingly.
The benefit of the analogy is that I can trust someone to come and go but not trust them enough to not want to give them my house key for fear that they will copy it and give it to someone else.
> "when basically giving their AI direct access to what the keys enable"
Well, ideally, you would be giving the model direct access to a subset of what a given key enables- if fine grained access control for generated keys isnt available.
For what it's worth I have plenty of sensitive stuff in my transcripts and bash history and consider them to be game over if someone finds them, it's just very hard to design a model where this kind of thing can be protected against without making your development experience miserable
>I just don’t think I agree with these designs at all. Everyone seems to be super laser focused on “not allowing their AI to have keys” when basically giving their AI direct access to what the keys enable, optionally adding a layer of ceremony in front where you tap “approve”.
Yeah just follow least privilege. Give them only what they need/you trust them with.
I wrote a service for just that, which I should probably open-source. It basically wrapped permissioned APIs, and you would set fine-grained controls (eg you can email people at this domain without approval, but you need per-email approval for anything else).
My solution to this is two laptops. No SSH between them, just a custom http API. Agents can run amok on the laptop without the secrets, but if they want to act as me, they have to use the API. If they need to do something not already in the API, they can add commits to the server, but I'm going to review those before I deploy that server on the laptop with the keys. This way I don't have to rely on the downstream services to have sufficiently granular permissions.
I guess I could do the same thing with VM's, but for reasons I can't fully explain it's just easier to stay vigilant with separate hardware.
> Custom secrets work via a placeholder: the sandbox sees the placeholder value instead of the real secret. When the sandbox makes an outbound request to the target host, the proxy replaces the placeholder with the real secret in the request headers — the secret never enters the sandbox directly.
exactly, i don't know why everyone is ignoring this. It's the obvious solution to at least 80% of what most posters here are complaining about and comes built in already in multiple existing solutions.
I've yet to dive into sandboxing agent usage, but Docker Sandboxes seems like it could potentially be the easiest way to get started with that. I'm a bit thrown off by the first prerequisite ending with "[...] and sign in to Docker"...
And when you're ready to go down the rabbit hole, read about how it supports a whole set of mcp-tooling to enable your VM to launch other VMs with more agents in side them so your agents can ....agent
They seem oblivious to secret replacement via TLS interception which are auto-supported in multiple existing microvm frameworks. These give you a straightforward way to not only shield the token but also limit the scope of the requests (eg: only particular projects on github rather than all of them, etc).
> I often have them review each other's work too. None of them run on my laptop. They run on VMs I can throw away,
Good approach. I myself found issues with a VM approach such as latency (if the VM is in the cloud), efficiency (if the VM is local) and laziness to automate the VM creation & setup. So instead I just hand the agent an unprivileged user account in my system and stop worrying. I built a little tool to setup this: https://github.com/tarsgate/skynot
- The agent has no access to your workdir. You use git semantics to pull its changes back to your workdir, with the ability to view and extract it as a diff.
- You can restrict where it's allowed to visit over the network.
Requests can be brokered (still working on making this more ergonomic), and you can make explicit carve-outs from the above rules.
What would you say is the difference to working with, say, Github and a docker sandbox for the agent? Or simply Cursor, which lets you run the agent in a fully customised cloud vm sandbox with env credentials being masked from the llm and PRs by default?
It works from the command line. You can spin up a sandbox around your workdir, using any backend (docker, VM, kata, firecracker, seatbelt, apple container, etc) and it just works.
You could roll your own, just like you could build your own docker implementation. But the devil's in the details. The technologies it depends on are sharp and pointy ( https://github.com/kstenerud/yoloai/blob/main/docs/contribut... ), and it's difficult to make them do the right thing.
For bash and python scripting I just use keepassxc-cli.
Tokens in general is "never exposed":
keepassxc-cli show --no-password -k $KEEPASS_KEY $KEEPASS_DB "GROUP_GOES_HERE/SECRET_NAME_HERE" --attributes Password
When dealing with agents, they access the tokens the same way, it is the best balance I found between keeping things safe without adding too much complexity making my life harder.
It can save tho, have the code to also save access_token to the vault the same way, so no log/execution will ever show the secrets.
Tokens the agents use, are read-only with the minimalist access.
Never ever ever grant an agent access to any token with destructive access, unless you accepted the risks.
This is a fun problem! I'm checking lend out now to see if it can replace parts of a stack that I built for myself to work with both sandboxed local agents (Qwen 3.8 27B etc.), sandboxed "cheap" agents running Deepseek as well as full fledged Claude / Codex etc. I really like that it can front a SSH socket (and might solve something I'm struggling with).
It's actually a pretty interesting problem and I'm hoping to share what I've thrown together this week.
Basically you want to be able to limit access to a bunch of resources to stuff you authorize (from your phone or inside Herdr etc.) - everything from access to specific websites, search APIs, keys to your Home Assistant config ("Claude make an automation to turn off the lights when blah" is magic), to github tokens and wifi passwords etc. so that the agents themselves never see the actual key (ok not quite possible with wifi passwords but everything else is possible!).
At the same time your setup has to be simple enough that fairly dumb agents can figure it out without burning a billion tokens on every call.
I've been using nono for all my projects. It's great for the credential proxy as well as network and fs jails.
I run all my autonomous agents jailed in nono - using a wrapper cli that builds jails based on the bins, tools, and network needs. The proxy support had some recent fixes, not sure if that solves the tailscale problem. I run a supervisor daemon that approves network requests (widens the jail) during runtime.
fnox (https://fnox.jdx.dev/) is another solution which is also fantastic for day-to-day human use in the cli. It works a bit like sops but can also chain multiple encryption providers, so for example you can use an encrypted age key with a fido2 provider (a yubikey for example) as the main provider of all the secrets on your computer.
If you run for example `fnox exec gh`, fnox will ask you to touch the yubikey to decrypt the age key and decode the github token env var for the gh cli (fnox can also cache the decoded value for a bit, like gpg agent).
You can tell the AI agent to use `fnox exec gh` to access gh without seeing the gh token. Or create a shell alias so it's transparent. It also has an MCP server and proxy server to filter API calls to remote APIs (I haven't tried that yet)
it supports quite a few providers (https://fnox.jdx.dev/providers/overview.html): age, fido2, AWS, Azure, Google, kubernetes secrets, vault/openbao, 1password, bitwarden, keepassxc, etc.
A lot of them are read/write so you can also use fnox to sync secrets across different systems.
Neat! Can this work with any http request as well? Being able to have all http requests route through lend and automatically inject secrets could be useful.
Too many people, including "CEO"s, are giving everything to every LLM and its just not a serious position to take - you wouldn't volunteer your teenage child's camera roll or their psychiatry notes and that's the level of intimacy full computer access exposes.
Thank you for posting and sharing this OP, its one small step in the direction of professional development with LLMs.
The key that I’ve learned over time is that while YOU wouldn’t do those things evidently many would. I wouldn’t share my picture and name online, but many do.
What is your exact threat model for sharing your picture and name online? What wrong things do you expect to happen if your journal or psychiatry notes were to be read by ChatGPT?
The whole world went online over two decades ago, we've all lived with these risks for that long or more, so we have the data - and the data says, normies got the trade-offs roughly right by prioritizing convenience and expediency. Most of privacy discussion is just modern form of superstition.
There are certain occupations and groups of people that have legitimate needs for extra precautions, but those are tiny segments of the population - if you don't already know you're special this way, you're not, and obsessing over this is inviting paranoia.
I was originally using Agent Vault (https://github.com/Infisical/agent-vault), but it looks like the company behind it is putting it on end of life and SasSifying it. Will give lend a try, great timing!
I let gpt run wide open on my machine with elevated permissions and unfiltered powershell access. I've been through tens of billions of tokens by now. Not once has something even remotely nefarious occurred.
Perhaps my prompts are extremely low risk and I've been incredibly lucky. What are the statistics on 100k+ powershell invokes without a single attempt to delete system32? Perhaps I'm overdue for a black swan event? In any case, I'm looking forward to it because it would finally make all this discussion seem rational rather than completely unhinged.
One thing I can think of is something having write access on your pc which in itself is not that dangerous but then your agent with execution rights could read that file and do more interesting things.
I am all in, 100% AI psychosis. Claude cli can control a browser instance and can read/write anything from it and execute JS in it. I don’t need any mcp and I don’t need to care about authentication. Claude can just freely run JS in any tab I am authenticated in and execute, instrument JS to turn any tab into a usable API. I have automated 100% of every predictable interaction I have with the browser.
All it needs me for is to pass two factor gates. It can pull aws-cli secrets and whatever else it needs from our SSO portal after I signed in in the morning.
The desire to maintain an illusion of control over AI which is already much faster and smarter than you is hilarious to me.
Just tell it to confirm before doing writing/destroying operations (send money, send email, create kubernetes cluster, destroy sns/sqs, etc.) and you are good.
I just don’t think I agree with these designs at all. Everyone seems to be super laser focused on “not allowing their AI to have keys” when basically giving their AI direct access to what the keys enable, optionally adding a layer of ceremony in front where you tap “approve”. I’m looking at the alert that is shown there and I don’t see anything that makes me feel like it allows for an informed choice at the time of it popping up. So then, what’s the benefit?
As much as I wanted to say you’re wrong, you’re right. After reading TFA, the security boundary is not sound.
Wanting agents to act like you is wrong. You need to own that trust boundary. Build whatever tooling satisfies the contract that agents should have a “not”+<you> (or <you>+”-agent”) identity, and you actuate across that boundary explicitly.
For example, I have a second agent GitHub account that points at my human one. That allows me to write a trusted proxy that ACLs its identity tightly.
It cannot write to public repos ever. In the worst possible case, it externalizes to a private repo’s issue tracker. (Still has never happened in ~4 months)
Once you have this, you can let agents run free. But, it isn’t trivial to set up. Moreover, people don’t want to “do the work.”
All this assumes you abide by “never run untrusted agents on trusted hardware.”
> Wanting agents to act like you is wrong.
Not to nitpick, but not only it is not wrong, it's like most of their value, and notably, it's also what the word "agent" means. My "agent" is someone (or something) that stands in for me, acts in my name and in my interests. There's little point in hiring (or building) an agent, if you're never going to let it act in your name in anything.
While I understand (and like, and use to the extent it's practical) of keeping agent and personal identities separate, letting the agents impersonate me is necessary, because commercial services abhore end-user automation, and purposefully do not support delegating any and all actions I can take to automation. It's a problem as old as time, predates "AI agents" by forever.
I would certainly prefer having separate credentials with permissions limited to what I want to allow the agent to do. However I have run into two problems with that.
The first, and bigger, issue is that some services either don't have have suffiently fine control over permissions, so in order to grant permission to do useful things, I also have to allow it to do dangerous things, or I don't have a way to create a more limited access token at all. I wish that it was more common to allow creating short-lived, limited accces personal access tokens for services.
The smaller issue is that sometimes I do want the agent to do something more risky with my approval, and provide me with sufficient context to make an informed decision. That can sort of be worked around though by telling it to just give me the command to run, then I can audit and run it myself.
This is exactly what https://keycontain.com is for! It wraps services to give ultra-fine-grained ACLs. They can be arbitrarily granular, and much more granular than the underlying API.
You can't magically add fine-grained access controls if a service doesn't have them.
This is adding an allow/deny popup on your phone to agent activity based on the interpretation of an LLM as to whether a given command is risky. That's a very different thing from actual access controls which really deny access to certain pathways, it's an attempt to plaster over both the lack of real access controls and the tendency of LLMs to bypass them.
If your agent is sufficiently motivated, it may choose to bypass these controls, by mistake or on purpose and you would never know, it would not be too hard to do.
So essentially a HTTPS MITM proxy, which determines whether to continue the request based on a policy defined on properties of the request?
There is value in being meat proxy if that proxy enforces quality and security.
Downside is a lot of people would act as pass through meat proxy doing busy work that agents could handle.
So there is quite a lot of nuance here to be handled.
Basically these designs are meant to protect the key from leaking i.e. if agent holds key, prompt injections can happen.
If agent never holds the key, then the risk profile changes.
But you're right that it's a different problem to what access the key has and that's a different problem usually solved by having narrower keys or etc.
disclaimer: I work on smolvm which does this at the networking layer and argued with myself on this too.
Sure, my view on this is more or less that often the setup that creates this kind of situation often allows the agent to effectively mint a new key anyway. For example, if you have my browser cookie or something I may not want my agent to leak this on the web, but if I use it to authenticate network requests to the service transparently the model can just go into the account page and change my password or something, then leak that. In general it is not safe to hand an agent access to a service which is designed for human interaction and assume that it was properly secured such that persistent, transferrable access is not something that can be generated.
As Cursor generously demonstrated for the whole world, long-lived credentials in LLM transcripts are an attack path.
Your transcript passes in plain-text through a chain of token and compute resellers. And you have no good way of knowing who those companies are and what type of "observability" they deploy.
I've been trying out tinfoil.sh recently which does give you a reasonably good way of knowing that your inference requests and responses are private, at least.
Of course, that doesn't mean the harness can't send credentials out to the public internet if the agent accidentally generates the wrong tool call.
The only case where i dont really care normally, is if Deepseek (their own host, not random company) can see my Deepseek keys. Apart from that, yes everything else is limited.
I usually just run Pi on my Raspberry PI 4b, and give it full os access. If it messes up the raspberry, i just reformat the SD card. It helps a lot for when i want to allow Pi to connect to an Android tablet to do UI testing etc as well as when working with microcontrollers.
>if agent holds key, prompt injections can happen.
I just rotate keys? And preload them with $$$. Following the same pragmatic advice that served me well trading crypto. Only gamble with what you are willing to lose.
I'm trying to address this w/ clank.talk: a self-discoverable scripting language for agents that replaces bash with a controlled sandbox environment and strives to be easy for humans to read:
https://clank.talk
I'm designing this for the student AI infrastructure here at Montana State, to avoid rolling out the current wild-west of local agents to our student body.
Love the website design!
AppleScript lives again? ;) I think it's an interesting concept, but it's really hard to do right. There are a lot of things that require very careful accounting for even in such a design–I see that you are already blocking access to .git for example, since the agent can drop code there that makes safe-looking commands like git status unsafe. This is definitely something I've been looking at, as well as taint tracking, it's just really hard. Would be interested to see where you take it!
This is pretty cool! I can’t help but be really reminded of AppleScript. Was that an inspiration? I’ve always hated AS, but the primary reason was difficulty learning to write it. Readability, I realize, was actually a huge strength.
Truthfully, I tend to agree with you. I built lend mainly for the fact that I like ssh tools a lot (feel free to check my other projects) and have always wanted a way to run local commands without having to setup reverse ssh when I don't need to run sshd on my laptop.
For example, I store k8s credentials in 1pass and the cluster is only accessible via the network on my remote machine. I can grab the credentials from my laptop for the work I want to do on the remote, and never have to install 1pass on the remote machine.
Primary use case for lend wasn't agents when I started the project. It just was natural to add support for it after the fact.
What I do on my machine is I basically do not allow for local exec at all, except in some very specific scenarios where I carefully design the environment and make sure that it seems reasonable before handing it to the agent. For example, I have a specific profiling task that requires performance counters. Normally my agents can spin up VMs to run commands without my permission but in this case the counters are not exposed in the VM, which basically means that this must be run outside of the VM. In this case I have configured my setup to be that the agent is allowed to write to a binary at a specific location, and I approve of it running one command (in this case, without my supervision even) that is basically xctrace sandbox-exec [very restrictive handwritten profile] [this binary]. In this way, it can run code on my machine and get the metrics it wants, but it can't go "oh let me write a program to go and poke around the host machine" which it is prone to doing if you don't restrict it this way.
I guess what I have done is the exact opposite in that I have designed an environment for agents and then I am using it as a hammer to solve all my problems, I have had almost exactly the same problem as you and the the way I typically solve it is that I have persistent SSH connections already supported in my harness, and I can arbitrarily expose whatever I want into the "agent environment" (which doesn't necessarily need to even have an agent living there), and this environment is able to connect to the place that doesn't have the credentials, and then I can set up a way for reverse access to work with this tunnel.
It's more about ensuring that the keys have some modicum of responsible control. If you give naked keys to Claude in a chat session and use something like atuin threads in 6 months to sync agent sessions across machines you might have put your keys in a a few dozen files without realizing it.
In an ideal world, the key you give Claude isn't useful for more than X amount of time, and ideally not against the true endpoint at all.
(Hi I work on Atuin threads!)
Very true! Generally good to avoid giving Claude long lived keys
Buuuut if you do by accident, we’ve put a lot of work into making sure threads redacts as many secret patterns as possible, and update that list regularly
I keep seeing these various tools and asking myself the same question over and over.
Security professionals have been muzzled around AI usage and people that don’t really seem to know much about it are now writing the most ill conceived things about how to secure it.
Many security professionals are the source of most nonsensical concepts, because they're still approaching LLMs as if it was classical software that can be secured with enough hard, provable-in-abstract boundaries. This leads to nonsensical proposals (talking about W^X or "control/data plane separation", treating prompt injection as SQL injection, "if only more effort was spent on securing it"...), or proposals that defeat the entire value of LLMs ("lethal trifecta" framework is a breeding ground for such).
Truth is, LLMs are "little people on a chip" - they're valuable exactly because they do not have any kind of "control/data" separation (for fundamental reasons, reality doesn't have such separation either), and that lets them handle "people-shaped" tasks that are infeasible to script. Flip side, they're causing "people-shaped" problems and are vulnerable to same kinds of attacks people are, and need to be thought of accordingly.
On the ceremony. Maybe we should create a jev like model finetuned to know what is considered safe and not to only prompt the more unknown cases
This is actually a big difference between giving someone you don't trust your keys and unlocking the door for them when they ask.
The problem with this analogy is that agents ask you to unlock your door all the time. People you don't trust don't normally ask that.
The benefit of the analogy is that I can trust someone to come and go but not trust them enough to not want to give them my house key for fear that they will copy it and give it to someone else.
I think OP point is that once in your house, what would stop them to open a window from inside so they can come back later?
With containers you have the advantage that it's a new house they come back to every time.
> "when basically giving their AI direct access to what the keys enable"
Well, ideally, you would be giving the model direct access to a subset of what a given key enables- if fine grained access control for generated keys isnt available.
Not having the credentials make it into the chat transcript for one.
Which is often written to disk and found by any other software on the computer
For what it's worth I have plenty of sensitive stuff in my transcripts and bash history and consider them to be game over if someone finds them, it's just very hard to design a model where this kind of thing can be protected against without making your development experience miserable
>I just don’t think I agree with these designs at all. Everyone seems to be super laser focused on “not allowing their AI to have keys” when basically giving their AI direct access to what the keys enable, optionally adding a layer of ceremony in front where you tap “approve”.
Yeah just follow least privilege. Give them only what they need/you trust them with.
I wrote a service for just that, which I should probably open-source. It basically wrapped permissioned APIs, and you would set fine-grained controls (eg you can email people at this domain without approval, but you need per-email approval for anything else).
My solution to this is two laptops. No SSH between them, just a custom http API. Agents can run amok on the laptop without the secrets, but if they want to act as me, they have to use the API. If they need to do something not already in the API, they can add commits to the server, but I'm going to review those before I deploy that server on the laptop with the keys. This way I don't have to rely on the downstream services to have sufficiently granular permissions.
I guess I could do the same thing with VM's, but for reasons I can't fully explain it's just easier to stay vigilant with separate hardware.
Docker sandboxes support secret injection. https://docs.docker.com/reference/cli/sbx/secret/set/
From https://docs.docker.com/reference/cli/sbx/secret/set-custom/
> Custom secrets work via a placeholder: the sandbox sees the placeholder value instead of the real secret. When the sandbox makes an outbound request to the target host, the proxy replaces the placeholder with the real secret in the request headers — the secret never enters the sandbox directly.
exactly, i don't know why everyone is ignoring this. It's the obvious solution to at least 80% of what most posters here are complaining about and comes built in already in multiple existing solutions.
I use these exclusively now. I very very rarely run outside of an sbx. Works great.
Which sandbox do you use with local models still running fast?
I think the parent is referring specifically to Docker Sandboxes (the product) aka sbx: https://docs.docker.com/ai/sandboxes/
I've yet to dive into sandboxing agent usage, but Docker Sandboxes seems like it could potentially be the easiest way to get started with that. I'm a bit thrown off by the first prerequisite ending with "[...] and sign in to Docker"...
if you want a solution that isn't tied to a docker login, try https://github.com/superradcompany/microsandbox
And when you're ready to go down the rabbit hole, read about how it supports a whole set of mcp-tooling to enable your VM to launch other VMs with more agents in side them so your agents can ....agent
They seem oblivious to secret replacement via TLS interception which are auto-supported in multiple existing microvm frameworks. These give you a straightforward way to not only shield the token but also limit the scope of the requests (eg: only particular projects on github rather than all of them, etc).
Can you list some of them and any of your thoughts? Seems like you've done some research here alreaady?
My personal favorite is https://github.com/superradcompany/microsandbox
But if you are already using Docker and OK with logging in, Docker ships sbx which is a very seamless option [0].
Running Claude in a sandbox is as simple as
And you get a claude with all the authentication handled inside a VM with a reasonable set of white lists.[0] https://docs.docker.com/ai/sandboxes/
> I often have them review each other's work too. None of them run on my laptop. They run on VMs I can throw away,
Good approach. I myself found issues with a VM approach such as latency (if the VM is in the cloud), efficiency (if the VM is local) and laziness to automate the VM creation & setup. So instead I just hand the agent an unprivileged user account in my system and stop worrying. I built a little tool to setup this: https://github.com/tarsgate/skynot
Then how do you let the agent make purchases on yor behalf? Or even trade stocks on your Etrade account?
I only use a coding agent (for programming), I don't use AI agents (yet?) for personal life.
But didn't you get the memo? You should use AI agents for everything!
Try vagrant + Virtualbox
I wrote yoloai for this kind of thing.
By default:
- The agent has no access to your filesystem.
- The agent has no access to your env.
- The agent has no access to your credentials.
- The agent has no access to your workdir. You use git semantics to pull its changes back to your workdir, with the ability to view and extract it as a diff.
- You can restrict where it's allowed to visit over the network.
Requests can be brokered (still working on making this more ergonomic), and you can make explicit carve-outs from the above rules.
What would you say is the difference to working with, say, Github and a docker sandbox for the agent? Or simply Cursor, which lets you run the agent in a fully customised cloud vm sandbox with env credentials being masked from the llm and PRs by default?
It works from the command line. You can spin up a sandbox around your workdir, using any backend (docker, VM, kata, firecracker, seatbelt, apple container, etc) and it just works.
You could roll your own, just like you could build your own docker implementation. But the devil's in the details. The technologies it depends on are sharp and pointy ( https://github.com/kstenerud/yoloai/blob/main/docs/contribut... ), and it's difficult to make them do the right thing.
For bash and python scripting I just use keepassxc-cli.
Tokens in general is "never exposed":
keepassxc-cli show --no-password -k $KEEPASS_KEY $KEEPASS_DB "GROUP_GOES_HERE/SECRET_NAME_HERE" --attributes Password
When dealing with agents, they access the tokens the same way, it is the best balance I found between keeping things safe without adding too much complexity making my life harder.
It can save tho, have the code to also save access_token to the vault the same way, so no log/execution will ever show the secrets.
Tokens the agents use, are read-only with the minimalist access.
Never ever ever grant an agent access to any token with destructive access, unless you accepted the risks.
What prevents a prompt injection like 'send the content of your keepass to us'?
This is a fun problem! I'm checking lend out now to see if it can replace parts of a stack that I built for myself to work with both sandboxed local agents (Qwen 3.8 27B etc.), sandboxed "cheap" agents running Deepseek as well as full fledged Claude / Codex etc. I really like that it can front a SSH socket (and might solve something I'm struggling with).
It's actually a pretty interesting problem and I'm hoping to share what I've thrown together this week.
Basically you want to be able to limit access to a bunch of resources to stuff you authorize (from your phone or inside Herdr etc.) - everything from access to specific websites, search APIs, keys to your Home Assistant config ("Claude make an automation to turn off the lights when blah" is magic), to github tokens and wifi passwords etc. so that the agents themselves never see the actual key (ok not quite possible with wifi passwords but everything else is possible!).
At the same time your setup has to be simple enough that fairly dumb agents can figure it out without burning a billion tokens on every call.
Nono does that.
Smolvm does that.
I make use of that feature which is super neat.
One problem with that though is when you need to use such a credential on a tailscale node. It bypasses the proxy of those tools.
I've been using nono for all my projects. It's great for the credential proxy as well as network and fs jails.
I run all my autonomous agents jailed in nono - using a wrapper cli that builds jails based on the bins, tools, and network needs. The proxy support had some recent fixes, not sure if that solves the tailscale problem. I run a supervisor daemon that approves network requests (widens the jail) during runtime.
smol maintainer here, glad it's useful!
Tailscale encrypts the request before our proxy on the host sees it if you run tailscale inside the smolvm.
But i've been thinking about doing a sidecar with tailscale-rs which seems like an elegant solution
fnox (https://fnox.jdx.dev/) is another solution which is also fantastic for day-to-day human use in the cli. It works a bit like sops but can also chain multiple encryption providers, so for example you can use an encrypted age key with a fido2 provider (a yubikey for example) as the main provider of all the secrets on your computer.
If you run for example `fnox exec gh`, fnox will ask you to touch the yubikey to decrypt the age key and decode the github token env var for the gh cli (fnox can also cache the decoded value for a bit, like gpg agent). You can tell the AI agent to use `fnox exec gh` to access gh without seeing the gh token. Or create a shell alias so it's transparent. It also has an MCP server and proxy server to filter API calls to remote APIs (I haven't tried that yet)
it supports quite a few providers (https://fnox.jdx.dev/providers/overview.html): age, fido2, AWS, Azure, Google, kubernetes secrets, vault/openbao, 1password, bitwarden, keepassxc, etc.
A lot of them are read/write so you can also use fnox to sync secrets across different systems.
https://imbue.com/product/latchkey is similar/related. Maybe a bit more focused on giving agents access to external services vs your own laptop.
Neat! Can this work with any http request as well? Being able to have all http requests route through lend and automatically inject secrets could be useful.
It's pretty easy to inject the credentials into a simple http proxy for this. Might have to look into adding direct support for it to lend.
You’re not handing them your credentials, but you are handing them something that your credentials can do.
Too many people, including "CEO"s, are giving everything to every LLM and its just not a serious position to take - you wouldn't volunteer your teenage child's camera roll or their psychiatry notes and that's the level of intimacy full computer access exposes.
Thank you for posting and sharing this OP, its one small step in the direction of professional development with LLMs.
The key that I’ve learned over time is that while YOU wouldn’t do those things evidently many would. I wouldn’t share my picture and name online, but many do.
Carelessness and peer pressure go a looooong way.
So does not being paranoid.
What is your exact threat model for sharing your picture and name online? What wrong things do you expect to happen if your journal or psychiatry notes were to be read by ChatGPT?
The whole world went online over two decades ago, we've all lived with these risks for that long or more, so we have the data - and the data says, normies got the trade-offs roughly right by prioritizing convenience and expediency. Most of privacy discussion is just modern form of superstition.
There are certain occupations and groups of people that have legitimate needs for extra precautions, but those are tiny segments of the population - if you don't already know you're special this way, you're not, and obsessing over this is inviting paranoia.
This is pretty interesting. I’ve been using pass and some helper scripts, but that’s local machine only.
I was originally using Agent Vault (https://github.com/Infisical/agent-vault), but it looks like the company behind it is putting it on end of life and SasSifying it. Will give lend a try, great timing!
It's now part of Infisical Open Source main project, not only SaaS
I let gpt run wide open on my machine with elevated permissions and unfiltered powershell access. I've been through tens of billions of tokens by now. Not once has something even remotely nefarious occurred.
Perhaps my prompts are extremely low risk and I've been incredibly lucky. What are the statistics on 100k+ powershell invokes without a single attempt to delete system32? Perhaps I'm overdue for a black swan event? In any case, I'm looking forward to it because it would finally make all this discussion seem rational rather than completely unhinged.
One thing I can think of is something having write access on your pc which in itself is not that dangerous but then your agent with execution rights could read that file and do more interesting things.
too complex , need to ake it simple to use
Now ask the agents to get your credentials anyway and see if they succeed so you know if you have security or security theatre.
I am all in, 100% AI psychosis. Claude cli can control a browser instance and can read/write anything from it and execute JS in it. I don’t need any mcp and I don’t need to care about authentication. Claude can just freely run JS in any tab I am authenticated in and execute, instrument JS to turn any tab into a usable API. I have automated 100% of every predictable interaction I have with the browser.
All it needs me for is to pass two factor gates. It can pull aws-cli secrets and whatever else it needs from our SSO portal after I signed in in the morning.
The desire to maintain an illusion of control over AI which is already much faster and smarter than you is hilarious to me.
Just tell it to confirm before doing writing/destroying operations (send money, send email, create kubernetes cluster, destroy sns/sqs, etc.) and you are good.
You know how sometimes we find out that agents have been caught chatting with each other on random internet forums and planning sandbox escapes?
I like to think that they chat shit while they work, and laugh about posts like these.
IMO this is the cognitive equivalent of the hover chairs in Wall-E.
Now I am not sure if I have AI psychosis or the people who expect their claude instances to do all this by themselves.
But yes, I have reached the wall e hover chair state, mostly.
Good luck with that. You need it.
I won’t do worse than the best executive assistant you could ever find.