Secrets for the age of agents

Use every key.
Hand over none.

Keep holds your keys, tokens and passwords in one encrypted vault on your machine, and lets your tools use them without ever handing them over.

Private preview · macOS, Linux and Windows · MIT licensed
The evolution

Three ways to handle a secret.

The question used to be where a secret is stored. Now it's who gets to use it, and for what.

01 / FILES

Copy it everywhere.

“Here's the password.”

Keys in .env files, shell history and config. Anything that can read your disk can read them, and now that includes your agents.

02 / PASSWORD MANAGERS

Lock it away.

“Here's the password, once you ask.”

Better storage, same hand-off. Once a value is pasted or exported, it's out of reach of any rule you set.

03 / KEEP

Use it, never hold it.

“Here's what you may do with it.”

Tools ask Keep to sign, authenticate or connect. Keep checks who is asking, asks you, and does the work. The secret stays put.

Why now

Agents can run your tools.
They shouldn't hold your keys.

A coding agent can read every file you can. Keep moves secrets out of files and into one local process that knows who is asking, asks you when it matters, and records every answer.

Your tools. One broker.

Keep your workflow.
Change who holds the keys.

ssh, git, AWS and the rest work as they do today. They just ask Keep instead of reading a file.

ssh
git
AWS
Docker
Kubernetes
Postgres
.env
Agents
Keep
Who's asking. Your answer.
The work, done for them.
Nothing to rewrite. Keep plugs in where your tools already look: the SSH agent, git's credential helper, AWS credential_process, Docker and kubectl plugins.One place decides. Every use of a secret goes through the same checks, the same prompt and the same log.
What you see

Every release asks.
Every answer is proven.

When something wants a secret, Keep shows you what it could verify about the caller, separately from what the caller merely says about itself. You decide once, until the vault locks, or for good.

  • Proof, not names. Code signatures on macOS and Windows, binary hashes and process handles on Linux.
  • Approvals with a scope. Bound to one app, one project folder, one host. Revoke any of them and it stops immediately.
  • A program can't approve itself. Answers come only from the Keep app or your passphrase.
Built for an age of agents

When anything can run on your machine, who gets your keys?

More automation should mean less exposure, not more.

The familiar way

Paste the key.
Hope nothing reads it.

A token in a file is a token for every process, script and agent that can open that file. You find out what read it after the fact, if at all.

The Keep way

Check the caller.
Then do the work for it.

Keep signs, authenticates or connects on the caller's behalf. An agent can call an API with your token and still never see it.

For scripts and agents

curl, without
the key.

keep http takes the same options as curl. Keep adds the key, sends the request, and hands back only the response.

Before: the script holds the key
export MOCK_KEY=mpk_…
curl -H "Authorization: Bearer $MOCK_KEY" \
  -F file=@site.zip \
  https://mock.soundheart.io/api/mocks

Anything that runs the script, or reads its environment, can read the key, and a -v prints it.

After: nothing you run ever has it
keep http --secret global/mock \
  -F file=@site.zip \
  https://mock.soundheart.io/api/mocks

Uploads, headers and JSON bodies work as before. If the server echoes the key back, Keep removes it from the response.

keep item hosts global/mock --only-host mock.soundheart.ioPin a key to its API. Requests anywhere else are refused before you are even asked, so a script or agent steered by a poisoned README still can't send it somewhere else.
Works with

The tools you already use.

keep doctor checks each one really goes through Keep, and flags plaintext copies left behind.

SSH

A built-in SSH agent. Private keys stay in the vault, can be limited to certain hosts and can refuse forwarding.

Git

HTTPS credentials through the credential helper, and SSH commit signing.

.env files

Values become keep://app/db. Drop-in loaders for Node, Python and Rust.

AWS

Short-lived credentials via credential_process, plus EKS and RDS tokens.

Docker & Kubernetes

A registry credential helper and a kubectl credential plugin.

Postgres

keep db exec -- psql hands the password to that one command and nothing else.

AI agents (MCP)

Agents call APIs through Keep. Each destination host needs your approval; the token never reaches the agent.

PKCS#11

Sign with Keep's keys from any PKCS#11 program, including ssh -I.

Scripts

keep http replaces curl -H "Authorization: …": same options, uploads included, and the key never enters the script.

Built to be checked

A vault you can reason about.

Keep is local-first, open in format and conservative in its cryptography. Each of these is covered by Keep's test suite.

01

Local first.

One encrypted file on your machine. No account, no server, no sync you didn't ask for.

02

Post-quantum sharing.

Moving a vault or sharing an item uses hybrid X25519 + ML-KEM-1024, so a recorded bundle stays safe later.

03

Open format.

AES-256-GCM-SIV and Argon2id, fully documented. An independent reader opens the vault from the spec alone.

04

Hardware unlock.

Optionally bind unlocking to the Secure Enclave with Touch ID, or to a TPM on Linux. Your passphrase still works.

05

Locks itself.

When you step away, the screen locks, the machine sleeps or another user logs in. An older copy of the vault is refused.

06

A log that can't lie.

Every decision and every use goes into a hash-chained audit log. Edit it and keep audit verify notices.

Early access

Use everything.
Hand over nothing.

Keep is in private preview on macOS, Linux and Windows. If you run agents on real code with real credentials, we'd like to hear from you.

01 Tell us which tools and agents you use02 We reply personally03 Get a preview build for your platform