Keys end up everywhere
Env files, CI runners, notebooks, a colleague's laptop. Nobody can answer which credentials exist, or which agent is using which one.
Carbono Dev · Managed OneCLI
Your agents
never hold
the keys.
Graphite is the managed secret gateway Carbono Dev operates for your AI agents. Credentials live in one encrypted vault. Agents ship with placeholders, call APIs normally, and the gateway swaps in the real secret on the way out.
The problem
Every agent you ship is another copy of your API keys.
Autonomous agents call dozens of services. The default answer — paste the key into the environment — multiplies your secrets across machines, prompts, logs and model context. Three things break at once.
Rotation stops happening
When a key lives in fifteen places, rotating it is an outage risk. So it doesn't get rotated, and a two-year-old production key stays live.
No record of agent behaviour
An agent with a raw key calls the vendor directly. You find out what it did from the vendor's bill, not from your own audit trail.
How it works
One vault. Placeholder keys. A swap at the edge.
Graphite runs the open-source OneCLI gateway: a Rust proxy that matches each outbound request to a stored credential and injects it as a header or query parameter. Your agent code does not change.
STEP 01
Store the credential once
Real secrets go into the vault encrypted with AES-256-GCM, scoped to a project, and matched to the hosts and paths they are allowed to reach.
# stored once, by a human, in the dashboard secret stripe:prod host api.stripe.com path /v1/* inject header Authorization: Bearer <value> grants agent-07, agent-12
STEP 02
Give the agent a placeholder
The agent gets a fake value and an access token, and points its HTTP client at the gateway. It never receives — and cannot read — the real secret.
# the agent's entire configuration HTTPS_PROXY=https://graphite.carbonodev.com PROXY_TOKEN=oc_agent_07_•••• STRIPE_API_KEY=ONECLI_STRIPE_KEY # placeholder
STEP 03
The gateway swaps and logs
On each call the gateway authenticates the agent, checks the grant, decrypts the secret at request time, rewrites the header, and records who called what.
# audit trail, written for every request 15:04:22 agent-07 api.stripe.com/v1/charges 200 41ms 15:04:39 agent-12 api.github.com/repos/… 200 88ms 15:05:01 agent-12 api.openai.com/v1/… 403 no grant
What "managed" means
You keep the secrets policy. We keep the gateway up.
OneCLI is open source and you are welcome to run it yourself. Graphite exists for teams who would rather not own a piece of security infrastructure on the critical path of every agent call.
Provisioning
Your own isolated gateway and database on your subdomain, configured with your hosts, grants and agents.
Upgrades & patching
We track upstream OneCLI, test each release against your configuration, and roll it out in a maintenance window you agree.
Monitoring & on-call
Health checks, latency and error-rate alerting on the proxy path, with a named Carbono engineer on the other end.
Key rotation runbooks
Rotate a vendor credential in one place. Every agent keeps working, because no agent ever held the old value.
Access & audit
SSO for your team, per-agent grants, and an exportable audit log of every state change and every proxied request.
Backups & recovery
Encrypted daily backups of the vault, restore drills, and a documented recovery path we have actually run.
No lock-in
Built on open source, on purpose.
Graphite runs OneCLI, an Apache-2.0 gateway anyone can read, audit and run. We add the operations, not a proprietary cage. If the relationship ends, your setup keeps working.
Carbono Dev on GitHub →- Apache-2.0 gateway and dashboard — no closed core on the request path.
- Your data stays yours: export the vault and audit log at any time.
- Leave and self-host with the same container image we run for you.
- Security reviewable end to end, by your team or an external auditor.
- Upstream fixes flow to you; our operational fixes flow back upstream.
Questions
The things teams ask first.
Can Carbono Dev read our secrets?
Secrets are encrypted at rest with a key held by your instance and decrypted only in the gateway process at request time. Operational access is limited, logged, and covered by the engagement agreement — and because the stack is open source, you can verify the handling rather than take our word for it.
What happens if the gateway goes down?
Agent calls that route through the proxy fail closed — they do not fall back to unprotected credentials. That is the point. We monitor the proxy path and agree an availability target and escalation path with you up front.
Do we have to change our agent code?
In most cases you set a proxy environment variable and replace each real key with a placeholder. Anything that speaks ordinary HTTP works, whatever framework or language the agent is written in.
Where does it run?
On infrastructure we operate, in a region you choose, or inside your own cloud account if you prefer the data never to leave it. Both are the same container image.
How does signing in work?
Graphite supports Sign in with Google. We request only your basic profile — your Google account id, name, email address and profile picture — so we can create your account and attribute entries in the audit log. We request no Gmail, Drive, Calendar or other sensitive scope. Graphite's use and transfer of information received from Google APIs adheres to the Google API Services User Data Policy, including the Limited Use requirements. Full detail is in our Privacy Policy.
How do we get started?
A short call to map the services your agents call and the credentials behind them, then a pilot on one agent. Most pilots are live within a week.
Get started
Take the keys away from your agents.
Tell us which services your agents call. We will show you what the swap looks like on one of them, on a call, with your own credentials never leaving your side.