AI agents are everywhere. They schedule meetings, triage support tickets, write code, manage infrastructure, and orchestrate multi-step workflows across dozens of enterprise systems. But ask a simple question — which agent did this, who authorized it, and should it be trusted? — and most organizations have no answer.
Today we are announcing Machine Identity, a new Truthlocks capability that brings cryptographic identity, authorization, and accountability to AI agents. At its core is the Machine Agent Identity Protocol (MAIP), an open specification that any platform can adopt.
The Problem: Agents Without Identity
Human identity infrastructure is mature. We have passwords, multi-factor authentication, SSO, role-based access control, and audit trails. When a person accesses a system, we know who they are, what they are allowed to do, and we can hold them accountable.
AI agents have none of this. Most agents authenticate with shared API keys or service accounts that reveal nothing about which agent is acting, what scope it was authorized for, or how much it should be trusted. The consequences are serious:
- No identity: When an agent calls an API, the receiving system cannot distinguish between Agent A (a well-tested production workflow) and Agent B (an experimental prototype). They share the same credentials.
- No authorization boundaries: An agent authorized to read customer records can also write to them, delete them, or escalate to other services — because there is no mechanism to express fine-grained agent scopes.
- No accountability: When something goes wrong — data corruption, unauthorized access, runaway costs — there is no audit trail connecting the action to a specific agent with a specific purpose.
- No trust differentiation: A brand-new agent and a battle-tested agent with months of clean operation history are treated identically by every system they interact with.
As enterprises deploy more agents with more autonomy, this gap becomes a security, compliance, and operational risk that cannot be ignored.
The Solution: Machine Agent Identity Protocol
MAIP defines a complete identity lifecycle for AI agents. Every agent gets a cryptographically verifiable identity — a DID (Decentralized Identifier) anchored to the Truthlocks trust registry — along with scoped authorization, behavioral trust scoring, and managed sessions. The protocol has six core components:
1. Agent Registry
Every agent is registered with a unique identity that includes its name, owning tenant, capabilities, and the cryptographic keys used to authenticate its actions. Registration creates an immutable record in the trust registry. The agent receives a DID of the form did:truthlock:agent:<uuid> and a key pair for signing requests.
Agent registration is performed through the console or the API. The registry supports metadata — description, version, owning team, environment — so that security teams can inventory every agent operating in their organization.
2. Trust Scores
Not all agents deserve the same level of trust. A freshly registered agent with no operational history should not have the same access as an agent that has been running cleanly in production for six months. MAIP introduces a trust score that quantifies an agent's reliability based on its behavioral history.
Trust scores are computed from multiple signals: successful task completion rate, error frequency, scope violation attempts, anomalous behavior patterns, and time in operation. Scores range from 0 to 100 and are updated continuously. Systems that consume MAIP identities can set minimum trust score thresholds — for example, requiring a score of 80 or above to access sensitive financial data.
3. Scope-Based Authorization
MAIP uses a hierarchical scope system to define what an agent is allowed to do. Scopes follow a resource:action pattern — for example, customers:read, orders:write, billing:admin. Scopes are assigned at registration time and enforced at every API boundary.
Scope hierarchies support wildcards (customers:*) and negation (!customers:delete) for flexible policy expression. When an agent attempts an action outside its authorized scopes, the request is rejected and the violation is logged — contributing to the agent's trust score calculation.
4. Session Management
Agents operate in sessions — bounded execution contexts with a defined start time, maximum duration, and scope ceiling. Sessions provide temporal boundaries for agent activity. When a session expires, the agent must re-authenticate to continue operating. Sessions can be revoked in real time if suspicious activity is detected.
Session tokens are short-lived JWTs signed by the Truthlocks platform. Each token encodes the agent's DID, authorized scopes, trust score at issuance time, and session expiry. Receiving systems validate the token without calling back to Truthlocks, enabling low-latency authorization checks.
5. Witness Network
Every significant agent action — scope request, session creation, tool invocation, delegation event — is recorded in the Truthlocks transparency log as a witnessed event. The witness network provides a tamper-evident audit trail that answers the question: what did this agent do, when, and under what authority?
Witnessed events are cryptographically chained and include inclusion proofs against the transparency log's signed tree head. Security teams can query the witness log by agent DID, time range, event type, or scope to investigate incidents or satisfy compliance requirements.
6. Cross-Tenant Delegation
In multi-organization workflows, an agent owned by Tenant A may need to act on resources owned by Tenant B. MAIP supports cross-tenant delegation — a structured process where the delegating tenant issues a time-bounded, scope-limited delegation credential that the receiving tenant can independently verify.
Delegation credentials are themselves MAIP attestations, signed by the delegating tenant's keys and recorded in the transparency log. The receiving tenant can verify the delegation without trusting the delegating tenant's infrastructure — the cryptographic proof is self-contained.
Kill Switch: Emergency Agent Revocation
When an agent goes rogue — whether due to a bug, a prompt injection attack, or a compromised key — you need to stop it immediately. MAIP includes a kill switch that instantly revokes an agent's identity, invalidates all active sessions, and broadcasts a revocation event to all connected systems.
Kill switch activation is available through the console (one click), the API (one call), and via automated policy rules (e.g., "revoke any agent whose trust score drops below 20"). Revocation propagates within seconds through the transparency log's real-time synchronization channel.
AI Orchestration Integration
MAIP is designed to work with the major AI orchestration frameworks. Agents built with LangChain, CrewAI, AutoGen, or custom orchestration systems can adopt MAIP identity by integrating the Truthlocks SDK. The SDK handles agent registration, session management, scope enforcement, and event witnessing — adding identity to existing agent workflows without requiring a rewrite.
For platform builders, the MAIP API provides primitives for building custom orchestration logic: register agents, create sessions, validate tokens, query trust scores, and manage delegations programmatically.
Open Source: MAIP Protocol Specification
We believe machine identity should be an open standard, not a proprietary lock-in. The MAIP protocol specification is published under the Apache 2.0 license at github.com/truthlocks/maip. The specification covers:
- Agent identity data model and DID method
- Scope hierarchy and authorization semantics
- Trust score computation algorithm
- Session token format and validation
- Delegation credential structure
- Witness event schema and transparency log integration
The specification is designed to be implementable by any platform. Truthlocks provides a production-grade implementation, but organizations are free to build their own MAIP-compatible systems. We welcome contributions, feedback, and interoperability testing from the community.
Billing and Availability
Machine Identity is available on all Truthlocks plans — Starter, Professional, and Enterprise — with usage-based metering. You pay for what you use:
- Agent registrations: Metered per registered agent per month.
- Session tokens: Metered per session created.
- Verification calls: Metered per identity verification or trust score query.
- Witness events: Metered per event recorded in the transparency log.
Starter plans include a generous free tier for development and testing. Enterprise customers can negotiate volume commitments. See the pricing page for current rates.
Getting Started
Machine Identity is available today. Here is how to get started:
- Read the docs: The Machine Identity guide walks through agent registration, session management, scope configuration, and trust score monitoring with code examples.
- Explore the API: The API reference covers every endpoint with request/response schemas.
- Review the spec: The MAIP specification on GitHub provides the protocol-level details for implementers and security reviewers.
- Start building: Sign in to the Truthlocks Console to register your first agent and create your first session.
AI agents are becoming the new workforce. They deserve the same identity infrastructure we built for humans — cryptographic, auditable, and trustworthy. Machine Identity makes that possible.