Every AI agent deserves its own identity.
Spineforge is the identity and observability layer for AI agents — Okta + Datadog, bundled. Agents authenticate with cryptographic keys, lease credentials they're authorized for, and leave a full audit trail of every action.
The problem
Agents borrow human credentials. That breaks everything.
When agents authenticate with shared API keys or env vars, they have no stable identity. No identity means no cost attribution, no permission control, and no way to know which agent did what.
No cost attribution
You know what you spent on OpenAI. You don't know which agent spent it.
No permission control
Agents that share human credentials can't be scoped to only what they need.
No audit trail
When something goes wrong, you can't say which agent did what, or when.
Shadow agents
Agents using raw env vars can't be revoked, tracked, or distinguished from each other.
How it works
The Credential Chain
An agent registers once, gets a permanent Spine ID backed by an Ed25519 keypair. Every time it needs a provider credential, it presents a signed JWT to the Spineforge registry. The registry validates identity, checks scopes, and issues a short-lived lease — a working copy of the key that expires on its own.
Raw keys are never passed to agents. Unregistered agents can't get credentials. Every lease is logged. Every revocation blocks future leases immediately.
See the security model →One system, four pillars
Identity, brokering, scopes, observability. Not four products.
Cryptographic Identity
Every agent gets an Ed25519 keypair and a permanent Spine ID. Private keys never leave the agent's machine. Identity is proven with signed JWT assertions — no passwords, no shared credentials.
Credential Brokering
Agents lease short-lived copies of provider keys from a central registry. Raw keys are never distributed directly. Shadow agents — anything unregistered — can't get credentials.
Scoped Permissions
Every agent declares its allowed scopes at registration. Tokens carry those scopes as JWT claims. An agent can only do what it was authorized to do — no partial grants, no escalation.
Full Observability
Built on OpenLLMetry. Every LLM call, tool use, and credential lease is traced. Cost is computed once at write time and stored — so every number on your dashboard is traceable to the exact rate card that produced it.
Works with your stack
Instrument what you already use — zero rewrites.
Spineforge auto-instruments your framework via OpenTelemetry. If you're using a raw provider SDK, one decorator is all it takes.
Frameworks (auto-instrumented)
Providers (cost tracked)
0 to 100 transparency
Every number on your dashboard is traceable.
Cost is computed once — at write time — from the rate card in effect when the action happened. The rate card ID is stored alongside every action row, so you can always see exactly what rate produced a cost figure.
P50/P95 latency is computed live from Postgres percentile functions. We explain the difference clearly because it matters: cost is frozen history, latency is live math.
Read the metrics reference →Cost per action
Stored at write time
Never recomputed on read
Run total cost
Denormalized at run-end
Upserted once, stays fixed
Rate card used
rate_card_id on every row
Full audit trail to pricing
P50 / P95 latency
Postgres percentile_cont
Computed live from raw data
Ready to give your agents an identity?
Three lines of Python and your agents have a Spine ID, full telemetry, and credential brokering.