What Is an AI Agent Identity?

TL;DR

›An AI agent identity is the governed record the agent acts as — not the LLM, not your workspace API key, not a string in a prompt.
›On Naïve it is a tenant user: an opaque record you manage via API, with cards, inbox, vault, connections, and sessions attached.
›The Account Kit assigned to that user defines what the identity may do; the governance gateway enforces it on every call.
›One identity per customer in a multi-tenant SaaS — structural isolation, not a system-prompt instruction.
›Agent profiles and MCP sessions are runtime handles bound to that identity; revoke the handle and the identity stops acting.
›Audit logs answer 'who acted?' at the identity level — which tenant user, under which kit, at what time.

Developers often conflate three things: the model (reasoning), the API key (authentication), and the identity (who the agent is in the real world). Only the third one answers "whose card was charged?" or "which customer's inbox sent that email?"

Naïve treats an AI agent identity as a tenant user — a governed record with its own resources, policy, and audit trail. This post is the definitional version; multi-tenant AI agents covers the full model.

What makes up an agent identity?

Piece	Role
Tenant user	The isolation boundary — every card, vault entry, connection, and session attaches here
Account Kit	Policy template — which primitives and apps this identity may use
Resources	Cards, email inboxes, vault entries, OAuth connections, verification records
Runtime handle	Agent profile or MCP session — how a specific run binds to the identity
Activity log	Immutable record of what this identity did, when, and under which policy

The model itself is not part of the identity. Swap GPT for Claude and the tenant user, kit, and resources stay the same.

How do you create one?

Two calls in the common case:

import { Naive } from "@usenaive-sdk/server";
const naive = new Naive({ apiKey: process.env.NAIVE_API_KEY! });
 
const user = await naive.users.create({ email: "customer@acme.com" });
const agent = naive.forUser(user.id);

Every regulated action after that runs as customer@acme.com's identity — not as a shared workspace actor. See Building AI Agents Into Your SaaS for the Operator → Account Kit → tenant user hierarchy.

Identity vs authentication

	Workspace API key	Tenant user (identity)
Lives on	Your trusted server	Naïve control plane
Scopes	Your operator account	One of your customers
Shared across tenants?	Yes — if you misuse it	No — forUser(id) is structural
Revocable per customer?	No — rotating hits everyone	Yes — revoke profile or session

Hand an untrusted runtime a session scoped to one identity, not your workspace key. See delegated, revocable MCP sessions.

Where identity shows up in governance

The Governed Agent Profile lifecycle — scope, approve, audit, revoke — all attach to an identity:

Spend caps apply per agent profile / tenant user budget
Approvals freeze actions for that identity until a human decides
Audit logs every call under that tenant user's ID
Revoke cuts off that identity's handles in one operation

Where to go next

What is an Account Kit? — policy on the identity
Tenant isolation in a multi-agent SaaS — verify isolation in production
Tenant users docs — API reference

Frequently Asked Questions

What is an AI agent identity?+

It is the governed record an agent acts as when it touches the real world — money, email, OAuth tokens, secrets, phone numbers. On Naïve that record is a tenant user under your operator workspace: an opaque ID you create and scope with forUser(id). The model is stateless; the identity persists across runs and owns every resource the agent creates.

Is an AI agent identity the same as a login account?+

No. A tenant user never signs in. It is a platform record you manage through the API, SDK, or CLI to represent one of your customers. Your app still handles end-user login; the tenant user is the isolation and policy boundary every Naïve primitive attaches to.

How is an agent identity different from an API key?+

An API key authenticates your server to Naïve. An identity is who the agent is acting for once authenticated. You keep the workspace key on your backend; you bind agent calls to naive.forUser(customerId) so cards, emails, and connections belong to that customer — not shared across tenants.

What controls what an agent identity can do?+

The Account Kit assigned to the tenant user. It enables or disables primitives, sets spend defaults, filters which third-party apps may connect, and gates sensitive actions on human approval. Policy is enforced server-side on every tool call — not described in the system prompt.

How do agent profiles and MCP sessions relate to identity?+

They are runtime handles bound to one tenant user. An agent profile is the long-lived execution context for hosted runtime; an MCP session is a short-lived scoped credential (default TTL 15 minutes, max 24 hours per published docs). Revoke either handle and the gateway denies further calls for that identity.

Why does identity matter for multi-tenant SaaS?+

Because without a per-customer identity, every agent action shares one bucket of credentials, spend, and audit. One prompt-injection or bug crosses tenants. Structural isolation — one tenant user per customer — keeps the blast radius to a single end-user's resources.

Naïve Team

Building the agent-native backend.

Keep reading

Multi-Tenant AI Agents: One Agent Per Customer, Isolated by Default

Multi-tenant AI agents give every customer their own isolated agent. Here's the operator, tenant-user, and Account Kit model behind per-user isolation.

Building AI Agents Into Your SaaS: The Multi-Tenant Playbook

Building multi-tenant AI agents into your SaaS means giving each customer an isolated, governed agent. Here's the full architecture and how to ship it.

The Governed Agent Profile: End-to-End Control for AI Agents

A governed agent profile is an AI agent with identity, spend limits, approvals, audit, and instant revoke — enforced on every action. Here's the full lifecycle.

What Is an Account Kit?

An Account Kit is a reusable policy template that governs what a tenant user's AI agents can do — which primitives are enabled and which apps they can connect.