Skip to content

Keys & Secrets In progress

Keep provider credentials in platform custody, with your own keys if you choose.

Agents call GitHub, Linear and other provider APIs without ever holding the credential. The platform keeps it in custody, adds it to the request on the way out and encrypts it at rest under a key you choose, all the way up to a key in your own cloud account that you can switch off at any time.

In progress, not ready for use

This page shows the product taking shape. Platform identity and gateway foundations are running today, while custody and provider connections remain in progress. Where it stands lists what is built and what is not.

Agents never see the secret ​

The credential lives only inside the custody boundary. Everything on the agent's side of it is plain HTTP.

AgentNever holds a credential
SupervisorSigns every request
Connection proxyChecks, then injects
Secrets serviceThe only place it is decrypted
Provider APIGitHub, Linear and more
  1. The agent sends plain HTTPNo token, no secret reference. The agent cannot pick the host or the credential.
  2. The supervisor signs itOutside the agent's code, the request is signed with a proof that lasts at most 60 seconds and works once.
  3. The proxy checks everything firstGrant, permission, egress policy and budget are checked, and the audit record is stored, before any credential is touched.
  4. Custody hands over the credentialThe secrets service resolves the connection's credential and refreshes OAuth tokens. The proxy holds it in memory only for the call.
  5. The provider answers, scrubbedCookies and credential-bearing redirects are stripped. If the credential echoes back, the call fails closed.

Keys inside keys ​

Every secret is sealed in layers, the way a letter goes in an envelope that goes in a safe. Each layer only opens the one directly inside it.

Key backendPlatform or you

The root of trust: the platform's OpenBao, or your own AWS KMS, Google Cloud KMS or OpenBao.

Key-encryption key (KEK)Never leaves the backend

Wraps and unwraps data keys. Everything else knows it only by an opaque KeyRef.

Wrapped data key (DEK)Stored next to the data

Encrypts the secret itself and is kept only in wrapped form. Unwrapped for one authorized operation, never cached.

Your secretCiphertext wherever it is stored

OAuth tokens, API keys and other provider credentials, encrypted under the data key.

Crypto-shredding. Destroy the KEK and every secret under it becomes unreadable at once, without touching the stored data.

Choose who holds the key ​

Start on a platform-managed key and move to a key you own when you need to. Moving re-wraps your existing secrets under the new key, with both keys available until the switch is complete.

Platform managed

Managed keyA shared key in the platform's OpenBao. Every use carries an authenticated binding that keeps tenants apart.
Dedicated keyA key of your own in the platform backend, so your data can be crypto-erased without touching anyone else's.

Customer managed: bring your own key

Disable the key in your provider and every use stops. The platform cannot override that, and it never falls back to a key of its own.

A key's life ​

A key moves through explicit states, and each state says exactly what it can still do.

  1. Active New secrets Read secrets The only state that protects new secrets.
  2. Decrypt-only New secrets Read secrets Retired from new work. Existing secrets stay readable, so you can migrate away.
  3. Disabled New secrets Read secrets Use is suspended.
  4. Pending destruction New secrets Read secrets Scheduled and reviewed, never instant.
  5. Destroyed New secrets Read secrets Gone for good. Everything it protected is unreadable.
With your own key, your provider decides. If it denies use, every operation stops right away, with no review step. Restore access and it works again. Destroy the key there and it is permanent.

What we promise ​

  • Agents never see a secretAn agent sends ordinary HTTP. It never receives a token or the right to look one up.
  • Fails closedWhen a check, a key or a provider fails, the call stops. There is no plaintext fallback.
  • Nothing secret in logs or streamsSecret values never reach logs or traces, and event streams carry no secrets, ciphertext or wrapped keys.
  • Your off switch winsWith your own key, disabling it in your provider stops every use. The platform cannot override it.
  • Every key use is auditedEach key operation leaves one audit record, and the proxy stores its audit record before any credential is used.
  • No silent fallbacksA caller never picks the key backend, the host or the credential, and a failing backend is never swapped for another.

Where it stands ​

  • Workload identity for platform servicesServices prove who they are with SPIFFE identities instead of shared tokens.Built
  • Tenant-scoped messaging credentialsCallers get NATS credentials bound to their tenant and to the subjects they may use.Built
  • Gateway credential storage and rotationWebhook secrets and bot tokens are stored in OpenBao, as a prototype inside the gateway.In progress
  • Key custody consoleScreens to register, bind, pause and migrate keys exist, running against a stand-in backend.In progress
  • Secrets service and connection proxyCredential injection on the way out, so agents never hold a credential.Designed
  • Envelope encryption and bring your own keyManaged and dedicated keys, plus AWS KMS, Google Cloud KMS and OpenBao backends.Designed
  • OAuth connections to providersConnect a provider once, and the platform exchanges and refreshes its tokens.Designed

Learn more ​

Understand the design

Set it up

Look up details

Released under the Apache License 2.0.