What is a digital identity for AI?

What is a digital identity for AI?

Most useful agent work lives behind a login. The hard part isn't the password — it's everything that isn't the password: the email confirmation, the SMS code, the consistent browser fingerprint that lets the same user return tomorrow without re-verifying. A digital identity is the bundle that handles all of that — the difference between an automation that runs once for a demo and one that runs reliably every day under a stable, accountable presence. Notte exposes it through the Persona class in the SDK; the public-facing name is "digital identity."

The problem digital identities solve

Three older approaches to giving an agent a usable online presence all decay:

1. Burner email plus a Twilio number, glued together by hand. Disposable email gets blocked by major SaaS within weeks, and Twilio numbers are flagged as VOIP and rejected by SMS-verification flows.
2. A single shared corporate account. Works for one workflow at one company. Doesn't scale to multi-user products: per-user isolation is impossible, and 2FA codes route to whoever owns that account.
3. Hand-coded fingerprints with manual cookie management. High setup cost, no realistic way to keep name + email + phone + fingerprint internally consistent, and per-session leakage every time storage state isn't persisted.

A digital identity collapses all three into one primitive: create once, reuse everywhere, with the bundle internally consistent and persistent across runs.

How a Notte digital identity works

from notte_sdk import NotteClient

client = NotteClient()

# Create a persistent digital identity with an attached vault.
identity = client.Persona(create_vault=True)

print(f"Email: {identity.info.email}")
print(f"Phone: {identity.info.phone_number}")

# Add credentials scoped to a target site — they go into the vault, not the LLM.
identity.add_credentials(url="https://github.com/")

# Run an agent against the identity. Sign-up forms auto-fill from the
# identity profile; 2FA codes are read from the inbox and submitted automatically.
with client.Session() as session:
    agent = client.Agent(persona=identity, session=session, max_steps=12)
    response = agent.run(task="Sign up at example.com and confirm via email.")

# Re-attach the same identity later — fingerprint, cookies, vault all carry over.
same_identity = client.Persona(identity.info.persona_id)

The SDK details that matter in production:

• The inbox is readable programmatically (identity.emails(only_unread=True, limit=10)), which is the primitive an agent uses to harvest 2FA codes and confirmation links — see how AI agents handle 2FA.
• The phone is real and SMS-capable, not a VOIP number that SMS-verification flows reject.
• The fingerprint is stable across runs, so sites that score "device trust" don't see a brand-new device every visit.

Common use cases

• Sign-up automation when the target site requires both email and SMS verification: the agent enrolls itself, reads the codes, submits them, no human in the loop.
• Multi-tenant products that issue one identity per end-user, with per-user isolation so one customer's session state never leaks into another's.
• Long-running monitoring (competitor pricing, regulator filings) where a fresh-fingerprint visitor every day gets rate-limited or flagged, but a stable identity is treated as a returning user.
• Authenticated scraping combined with credential vaulting — identity provides persistence, vault provides the secrets.

Key takeaways

• A digital identity is the persistent online presence Notte provisions for an agent: name, email, phone, vault, fingerprint — coherent and reusable across sessions.
• One SDK call (client.Persona(create_vault=True)) creates the bundle; another (client.Persona(persona_id)) reattaches it later.
• The three details that move autonomous auth from "demo" to "production" are: programmatically-readable inbox, real SMS-capable phone, stable fingerprint.
• Pair with credential vaulting for the password layer and agent identity for the broader conceptual frame.