The Attested Audit Trail for Every Credential Your Agents Touch
Mint issues short-lived, attested, per-agent credentials — and turns every issuance, use, and revocation into immutable, regulator-ready evidence. Prove what your agents can access, and what they did with it.
The Core Problem
Long-lived credentials stored in environment variables are catastrophic for AI agents. It is like giving every driver a master key to every car on the lot.
Long-lived credentials
Traditional secrets managers issue static API keys stored in environment variables. When an AI agent is compromised by prompt injection or memory exfiltration:
- Long-lived API keys in env vars
- Shared across all agent instances
- Manual rotation and revocation
- Stolen = compromised forever
Ephemeral by design
Mint issues short-lived tokens cryptographically bound to the issuing environment, and writes every credential event to an immutable audit log. When a token is exfiltrated:
- Env-bound token, 5-minute TTL
- Cryptographically tied to issuing environment
- Per-agent, every event audited
- Short-lived and environment-scoped — limited usefulness if exfiltrated
Four Steps to Attested Credentials and an Audit Trail
Mint attests the runtime, issues a bound token, and writes every event to an immutable log. Your agents operate. You have regulator-ready proof.
Attest the environment
On startup, the Mint SDK reads the execution environment — container ID, vTPM measurement, or workload identity — and presents it to the Mint service.
Issue a bound credential
Mint issues a short-lived token cryptographically bound to that specific environment. No other process — in any other sandbox — can use it.
Token auto-expires
Credentials expire in minutes, not months. No rotation scripts. No cleanup jobs. No forgotten keys. Just a credential that is dead by design.
Every event becomes attested evidence
Every issuance, use, expiry, and revocation is written to an immutable, timestamped audit log with the attested environment identity attached. This is the record that satisfies EU AI Act high-risk obligations, SOC 2 CC6, and ISO 42001 audits. Revoke any agent in one click; the revocation lands in the same trail.
Why Existing Tools Fall Short
Credential rotation is becoming a commodity — SPIFFE, Vault, and the model providers all do short-lived keys now. The gap is evidence: attested, cross-vendor, regulator-ready proof of every credential event.
SPIFFE / SPIRE: rotation without a record
SPIFFE and SPIRE issue attested, rotated workload identities — the rotation problem is largely solved. What they don't produce is a packaged, immutable, regulator-ready record of what each credential accessed, in which environment, and when. Attestation and audit are separate problems.
Mint wraps attestation with a per-event audit log — every issuance and use is timestamped, signed, and mapped to compliance frameworks.
Vault: powerful secrets engine, no compliance layer
Vault manages secrets well and can issue dynamic credentials. Its audit log records Vault operations — but those logs are not attested to the workload identity, not mapped to EU AI Act or SOC 2 CC6, and don't follow the credential across third-party provider calls.
Mint sits alongside Vault: Vault manages the secrets; Mint provides the attested, cross-vendor audit trail that regulators and auditors ask for.
Provider-native keys: every vendor logs in isolation
OpenAI, Anthropic, Databricks, and AWS Bedrock each maintain their own usage logs. You get siloed, unattested records per vendor — no single view of which agent used which credential, in which environment, at what time. Stitching that together for an audit is a manual, error-prone process.
Mint issues one attested identity per agent and captures a unified credential event record — regardless of which provider the credential targets.
Seamless Sandbox Injection
Mint integrates directly with your agent workloads. Execute your agents via the mint CLI to inject credentials on-the-fly, or import the lightweight SDK to dynamically retrieve verified credentials in attested sandboxes.
- CLI Injection: Run
mint execto automatically issue, validate, and inject secrets without changing any code. - SDK Fetching: Call
mint.get()inside Python, JS, or Go to retrieve credentials after an environment-binding handshake. - Zero Plaintext Storage: Ephemeral keys are fetched only inside verified sandboxes and auto-expire in 5 minutes.
$ mint init
# Initialized local environment security sandbox (~/.mint/)
$ mint add openai OPENAI_API_KEY
Enter credential value: *********
$ mint exec openai -- python agent.py
# Token generated, verified, and raw credential injected inside subprocess:
[✓] signature valid
[✓] expiry valid, expires in 299s
[✓] revocation not revoked
[✓] fingerprint match
# Subprocess executes; raw key is securely discarded from memory on exit
from mint import agent_creds
# SDK automatically attests environment & retrieves real ephemeral key from broker
api_key = agent_creds.get("openai")
# Drop directly into LangChain ChatOpenAI
llm = ChatOpenAI(api_key=api_key)
# Or use with any LLM library (e.g. LiteLLM)
resp = litellm.completion(
model="gpt-4o",
api_key=api_key,
messages=[{"role": "user", "content": prompt}]
)
import { agentCreds } from '@puremetrics/mint';
// SDK automatically attests environment & retrieves real ephemeral key from broker
const apiKey = await agentCreds.get('openai');
// Drop directly into the OpenAI SDK
const openai = new OpenAI({ apiKey });
const resp = await openai.chat.completions.create({
model: "gpt-4o",
messages: [{ role: "user", content: prompt }]
});
import "github.com/puremetrics/mint"
// SDK automatically attests environment & retrieves real ephemeral key from broker
apiKey, err := mint.Get("openai")
if err != nil { log.Fatal(err) }
// Drop directly into the OpenAI Go client
client := openai.NewClient(
option.WithAPIKey(apiKey),
)
Works with Every Library
Mint is a drop-in credential layer — not a framework replacement. Works with any library that accepts an API key.
Capabilities
Every issuance attested. Every use recorded. Every expiry and revocation timestamped and exportable. Built for teams shipping agents to production.
Full Audit Trail
Immutable, attested log of every credential issuance, use, expiry, and revocation — with environment identity attached to each event. Exportable evidence pre-mapped to EU AI Act high-risk obligations, SOC 2 CC6, ISO 42001, and OWASP Agentic Top 10. Compliance output by default, not an afterthought.
Live Dashboard
See every active credential in real time — which agent holds it, which environment it's bound to, and exactly when it expires. Full fleet visibility at a glance, with one-click revocation.
Environment Binding
Credentials are cryptographically tied to the issuing execution environment for attested and internal resources. Narrows the exposure window of a compromised token — pairs with your authorization layer rather than replacing it. Mint handles identity and the audit record, not access policy.
Auto-Expiry
Configurable TTL — default 5 minutes. No rotation scripts. No forgotten keys. No revocation ceremonies. Short-lived credentials reduce exposure windows and keep the audit record clean.
Instant Revocation
Kill any agent's credentials in one click — no key rotation required, no propagation delay. The revocation event is timestamped and written to the audit trail immediately.
Zero-Trust Runtime
No implicit trust — every credential request is attested before issuance. Works alongside your existing secrets manager: Vault, AWS Secrets Manager, or GCP Secret Manager.
Be First to Secure Your Agents
Early access opens to a limited cohort of teams running agents in production. No spam. No commitments. We'll reach out when Mint is ready for your stack.
by Pure Metrics AI