Open source · self-hosted · Rust

Secrets for you.Leashes for your agents.

One self-hosted store instead of scattered .env files. You sign in; every AI agent and CI job gets its own identity — scoped, read-limited, audited, revocable.

$ enveil run -- dx serve
12 secrets injected · 0 files written

Self-host from GitHub · Read the docs · No values ever on screen

the .env problem, now with agents

Your .env is in the context window

A coding agent that can read your repo can read .env — and paste it into a prompt, a log, or a pull request.

One token means everything

Hand an agent your personal token and it holds your reach across every project, with nothing slowing it down.

Nobody knows who read what

When a key leaks, the first question is who had it. With files, the answer is everyone and every backup.

This is the whole thing, running.

Import once, then prefix your commands. Values stay on the server; the page and the terminal only ever show key names.

~/projects/stepshots
$ enveil import
== .env → stepshots/dev
== .env.production → stepshots/prod
== .env.example skipped
$ enveil list
DATABASE_URL
STRIPE_KEY
$ enveil run -- dx serve
serving on http://127.0.0.1:8080 · 0 files written
audit agent claude-dev read 12 secrets throttled at 600/min

An agent is not a user. enveil does not pretend it is.

Every design choice starts from the same question: what happens when the thing holding the credential is running unattended?

Machine identities with read budgets

Each agent gets a token scoped to the environments it needs, with its own expiry and a limit on secrets read per minute and per hour. Going over is refused and recorded — a runaway loop shows up in the trail instead of draining prod.

agent claude-dev · stepshots/dev · read · 600/min

Nothing on disk

enveil run puts secrets into the child process and writes no file.

enveil run -- cargo test

CI without stored tokens

GitHub Actions proves who it is with its OIDC token. Each one is exchanged once, for an identity that expires in minutes.

permissions: id-token: write

Encryption that knows where it lives

Values are sealed under a per-project key and bound to their project, environment and name — ciphertext copied from prod into dev fails to decrypt. The master key rotates with one command, without re-encrypting a single value.

enveil-server rotate-master-key

Every read is on the record

The audit write sits inside the decrypt. If it cannot be recorded, the value is not returned.

read · who · what · when · from where

Undo without looking

Every write keeps the old value. Roll back a bad rotation without the credential ever being shown.

enveil rollback STRIPE_KEY 3

From twenty .env files to one command.

01

Sign in once

Browser login; the token goes to your OS keychain, never a file.

$ enveil login
02

Move a project in

.env goes to dev, .env.production to prod. Templates are skipped.

$ enveil init --create && enveil import
03

Run with it

Delete the files. Prefix the command instead.

$ enveil run -- dx serve

where the boundary is

With enveil run --proxy, secret values stay on the server. The local adapter holds placeholders and forwards requests; the server injects credentials only for their allowed HTTPS hosts. Substitution covers headers and the URL, not request bodies.

Give agents a proxy-only identity so they can use credentials without fetching them. Choose allowed hosts carefully: an upstream can still return a secret in its response, and proxy access still permits actions at that upstream.

Your secrets, on your server.

Rust, PostgreSQL, one container. Open source, built on the Oxidt kit.