Mint

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.

Env-Bound Token 5-min TTL

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.

The Server Way

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
The Mint Way

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.

01

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.

02

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.

03

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.

04

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.

Evidence Gap

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.

Evidence Gap

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.

Evidence Gap

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 exec to 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.
LiteLLM LangChain OpenAI SDK Anthropic SDK CrewAI AutoGen
mint — credential issuance
$ 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