Your agent gets a private browser.
That never loses its login.

Give your coding agent an email address — and accounts it can operate.

No custom agent required. The agent you already use every day can own a real inbox and real accounts — one pasted line and it provisions itself.

Honest by design: you click the final submit on signups, CAPTCHAs and email/SMS MFA hand off to a human, and some sites fraud-block automated signups.

Two doors. One account that stays alive.

Signup ends with an email your agent never gets.

Signup and login flows end with a verification email. If your agent has no inbox of its own, that's where the automation stops. Or worse, it runs on your personal accounts.

The verification inbox for browser agents.

Every inbound email is classified on arrival (OTP, magic link, or other) with the code or link already extracted. Your agent makes one call that blocks until the verification email lands, parsed and ready. Email content is treated as untrusted; extraction is hardened against prompt injection.

$ CODE=$(sente wait --identity support-bot --otp --timeout 60)   # blocks, prints just the code
$ LINK=$(sente wait --identity support-bot --magic-link)         # or just the link
$ echo $CODE
481923

import { Sente } from "@sente-labs/sdk";

const sente = new Sente({ apiKey: process.env.SENTE_API_TOKEN! });

const idt = await sente.identities.create({ name: "support-bot", localPart: "support-bot" });
// -> { id, email: "support-bot@sente.run" }

const since = new Date().toISOString();
// ...trigger the signup / login that sends the verification email...

const otp = await sente.messages.waitForOtp(idt.id, { since, timeout: 60 });
if (otp) console.log(otp.code); // e.g. "481923"

// links instead:
const ml = await sente.messages.waitForMagicLink(idt.id, { since, timeout: 60 });

import os
from sente import Sente
from datetime import datetime, timezone

sente = Sente(api_key=os.environ["SENTE_API_TOKEN"])

idt = sente.identities.create(name="support-bot", local_part="support-bot")
# -> support-bot@sente.run

since = datetime.now(timezone.utc).isoformat()
# ... trigger the app's "send code" action ...

r = sente.messages.wait_for_otp(idt.id, since=since, timeout=60)
if r:
    print(r.code)  # magic links: wait_for_magic_link(...)

A real address your agent owns, not a temp inbox.

Identities live on sente.run, are long-lived, and are reused across apps. Your org owns them; your agent operates them with a scoped API key.

Bring the accounts you already own.

Your org already has accounts — dashboards, portals, tools your agent should operate. Hand Sente the credentials once: it logs in, vaults them, and keeps the account alive with re-login on demand. The owner authorizes it, the owner can revoke it. No signup, no new account.

$ sente connect https://app.example.com/login --identity support-bot \
    --username ops@example.com --password ******** --totp-seed JBSWY3DP…
run_01hg…  queued → running → completed    connection active

$ sente session export conn_01hg… ./state.json  # Playwright storageState
$ sente connection delete conn_01hg…            # revoke AND purge the vault

Only connect accounts your org owns or is authorized to operate. Delegation is explicit, audited, and revocable at any time — that's the point.

From signup URL to a durable, signed-in account.

Give Sente an app's signup page and an identity. A managed browser registers, the verification code or magic link is picked from the identity's own inbox and applied automatically, and you get back an account that outlives the run: credentials in an encrypted vault, and a logged-in browser whenever you ask for one. For targets whose terms allow automated signup — and with confirm-before-submit when a human should form the agreement.

const { registration, run } = await sente.registrations.register({ identityId, appUrl: "https://app.example.com" });
await sente.runs.waitForRun(run.id);

// ...later, anytime...
const { cdpUrl, healed } = await sente.registrations.getSession(registration.id);
const browser = await puppeteer.connect({ browserWSEndpoint: cdpUrl }); // already logged in

res = sente.registrations.register(identity_id=idt.id, app_url="https://app.example.com")
sente.runs.wait_for_run(res.run.id)

# ...later, anytime...
s = sente.registrations.get_session(res.registration.id)
browser = playwright.chromium.connect_over_cdp(s["cdpUrl"])  # already logged in

$ sente register https://app.example.com --identity support-bot
run_01hf…  queued → running → awaiting_verification → running → completed 

$ sente session open reg_01hf…    # prints a CDP url, already logged in
$ sente credentials reg_01hf…     # vaulted username + password

The session can always be rebuilt, because Sente holds the account: the vault, the inbox, the re-login.

When a run can't proceed (a CAPTCHA, an unexpected step) it doesn't dead-end: it holds, surfaces a live view, and a person can clear the step and resume. Stable error codes tell you exactly why (CAPTCHA_REQUIRED, PHONE_REQUIRED, …).

Human-in-the-loop by design.

Sente is for agents that apps can see and choose to admit. Your org's human owns every identity and account; the agent operates them under delegated, auditable access.

Four commands. That's the whole required interaction.

$ npm i -g @sente-labs/cli
$ sente login                                   # browser sign-in; free tier, no card
$ sente identity create --name "support-bot" --local-part support-bot
→ support-bot@sente.run

$ sente wait --identity support-bot --otp       # blocks, prints just the code

Or skip the terminal: paste give my agent email capabilities via https://sente.run/skill.md into your coding agent and let it do this for you.

Running OpenClaw, Hermes, or another SKILL.md-compatible agent? Install the official skill: npx skills add sente-labs/skills · clawhub install sente — source at github.com/sente-labs/skills.