Your agents are already operating the internet.
Never as you.
AI agents are browsing websites, opening accounts, conducting research, moving assets and completing work through browsers built for humans. Most inherit the operator's sessions, logins, files and digital reach. Mortal gives every agent an identity of its own: a real isolated browser, private memory and files, scoped permissions, a network route you attach and a lifetime you define. Disposable for one task. Persistent for ongoing work. Destroyed when its purpose ends.
a task should never inherit more of you than it needs.
An agent without its own identity operates as whoever launched it.
It inherits their browser state, authenticated sessions, accounts, history and access. That works for demos. It does not work for autonomous systems operating continuously across clients, markets, accounts and workflows.
Mortal places a programmable identity between the agent and the internet. The agent receives exactly what it needs:
Your identity remains outside the environment.
Launch identities configured for different markets, languages, timezones and network routes.
Mortal does not sell documents, accounts, credentials or fabricated people. It provisions controlled environments. You provide any credentials and network routes required by the workflow.
Give each agent a persistent operational identity instead of access to your personal browser. It can build context over time without inheriting yours.
Launch region-specific research identities with dedicated routes, local browser settings and isolated downloads.
Keep one persistent identity per client. Sessions, notes, files and accounts never cross engagements.
Separate investigations, communities, projects and operational accounts into isolated environments with explicit permissions.
Enter your product as a clean user, returning user or user from another market without contaminating the test with existing browser state.
Provision an identity for a single operation and automatically destroy its managed state when the work ends.
create an identity. watch it end.
this simulator runs in the page with real logic: configure, provision, operate, destroy, receipt. it is a preview, not the product. real isolation requires the desktop manager.
one place to launch, operate and end identities.
every identity gets its own chromium profile, memory, files and permissions. the manager runs them side by side, enforces their lifetimes and records what was destroyed when they end.
every product frame below is a direct capture of the alpha. nothing is redrawn. diagrams and coming features are labeled as such.
the countdown is enforced by the runtime · a real chromium process, never a webview
what remains after destruction: the receipt
provisioned, operated, destroyed. on a schedule you set.
watch one identity live and end. this is a diagram, not a product screen. a task arrives, an identity is assembled around it, it operates, and when the work ends its managed state is destroyed.
compile a due-diligence report on one vendor from public filings
identities are compartments. while 008 lives and ends, your other identities do not react: no shared cookies, no shared history, no shared files. destruction is scoped to the one identity that ends.
what gets separated.
every guarantee has a test id and a label. enforced means the runtime imposes it. advisory means it is a default you can change. nothing here is marketing language.
mortal separates browser state, files and context. it does not provide anonymity in version one. identities running on the same machine share the host’s ip address and hardware characteristics. every guarantee is labeled enforced, advisory or roadmap. we do not sell controls that do not exist.
Install a complete operating environment for an agent.
A blueprint defines the browser setup, permissions, memory, files, region, route, lifetime and destruction policy before the identity launches.
Inspect every permission before launch. See which controls are enforced, which are configurable and what the identity can access.
What it does not have is an identity model built for them.
Companies will operate fleets of agents across research, support, procurement, finance, development and online operations. Those agents cannot all inherit the identity of the person who launched them. Mortal is the runtime that decides where an agent operates, what it remembers, what it can access and how long it is allowed to exist.
agent assignment and the sdk are not included in the alpha. every agent surface remains labeled coming until it ships.
const identity = await mortal.identity.launch({
blueprint: 'vendor-audit',
lifetime: '12h',
permissions: { network: 'standard', downloads: 'scoped' }
});
await identity.enforcement();
// → { browser: 'enforced', memory: 'enforced',
// files: 'enforced', network: 'advisory',
// lifetime: 'enforced' }
await identity.destroy();
// → receipt retainedone persistent identity per client. notes, links and context stay inside the engagement and never bleed into other clients.
one identity per investigation. sessions, files and history end when the work closes.
short-lived identities for fieldwork today. assigning them to agents ships later, and is labeled coming until it does.
launch isolated identities that disappear when their work is done.
a desktop app, on purpose.
mortal is a desktop app because real isolation needs real processes. the code is public. the builds are signed. the checksums are printed.