diff --git a/packages/agentenv-protocol/src/agentenv_protocol/website_browser/cdp.py b/packages/agentenv-protocol/src/agentenv_protocol/website_browser/cdp.py
index 721d6116e..562a8e4e1 100644
--- a/packages/agentenv-protocol/src/agentenv_protocol/website_browser/cdp.py
+++ b/packages/agentenv-protocol/src/agentenv_protocol/website_browser/cdp.py
@@ -22,6 +22,7 @@
                   redacted_params)
 
 if TYPE_CHECKING:
+    from .contexts import Contexts
     from .control import BrowserControl
     from .devtools import DevToolsPipe
 
@@ -51,6 +52,8 @@
 ENDS_BROWSER = frozenset({"Browser.close", "Browser.crash", "Browser.crashGpuProcess"})
 #: The commands that set how and where downloads are saved, which agentenv keeps as its own.
 SETS_DOWNLOADS = frozenset({"Browser.setDownloadBehavior", "Page.setDownloadBehavior"})
+#: The commands that make and end a browser context, which agentenv records as leases.
+MAKES_CONTEXT, ENDS_CONTEXT = "Target.createBrowserContext", "Target.disposeBrowserContext"
 #: The schemes of the browser's own files, settings and tools, which an agent's navigation or new tab may not open.
 OWN_SCHEMES = frozenset({"file", "chrome", "chrome-extension", "chrome-untrusted", "view-source", "devtools"})
 #: The ``about:`` pages that aren't the browser's own under another name.
@@ -158,10 +161,11 @@ class Verdict:
     changed: bool = False
 
 
-def guard(method: str, params: dict, *, dialogs_answered: bool) -> Verdict:
+def guard(method: str, params: dict, *, dialogs_answered: bool, download_path: Optional[str] = None) -> Verdict:
     """What the relay does with an agent's ``method``, so it can't end the browser others share, route around the site
-    proxy, save downloads elsewhere, open the browser's own pages or race the dialogs agentenv answers when
-    ``dialogs_answered``: a guardrail, since the sandbox's network is the boundary."""
+    proxy, save downloads elsewhere than its context's folder, ``download_path`` for a lease's, open the browser's own
+    pages or race the dialogs agentenv answers when ``dialogs_answered``: a guardrail, since the sandbox's network is
+    the boundary."""
     if method in ENDS_BROWSER:
         return Verdict("close", params)
     if method == "Target.exposeDevToolsProtocol":
@@ -173,8 +177,8 @@ def guard(method: str, params: dict, *, dialogs_answered: bool) -> Verdict:
     if method in ("Page.navigate", "Target.createTarget") and (scheme := _own_scheme(params.get("url"))):
         return Verdict("refuse", params, f"{scheme}: URLs open the browser's own files, settings and tools")
     if method in SETS_DOWNLOADS:
-        pinned = {"behavior": "default",
-                  **{key: params[key] for key in ("browserContextId", "eventsEnabled") if key in params}}
+        pinned = {"behavior": "default"} if download_path is None else {"behavior": "allow", "downloadPath": download_path}
+        pinned.update({key: params[key] for key in ("browserContextId", "eventsEnabled") if key in params})
         return Verdict("send", pinned, changed=pinned != params)
     if method == "Page.handleJavaScriptDialog" and dialogs_answered:
         return Verdict("answer", params)
@@ -212,6 +216,9 @@ def __init__(self, websocket: WebSocket, user: str, session: str, record: dict,
         self.outbox: asyncio.Queue[str | tuple[int, str]] = asyncio.Queue()
         self.waiting_bytes = 0
         self.closing = False
+        #: Whether it set how downloads are saved, and the contexts it made that end as it detaches.
+        self.set_downloads = False
+        self.ends_on_detach: set[str] = set()
 
 
 class _Call:
@@ -242,11 +249,14 @@ class Relay:
     browser's dialogs itself. With a ``log``, each command is an entry in it, on the tab its session is on, and
     ``control``, agentenv's own connection, tells its tab's URL, whether a password field has focus there, and what
     causes the tab events a command brings. An agent's tool call a driver serves through a CDP user's connections,
-    such as Playwright MCP's, is an entry too, which that user's commands are credited to while it's open."""
+    such as Playwright MCP's, is an entry too, which that user's commands are credited to while it's open. With
+    ``contexts``, a context a connection makes is leased to its user, only one it made may it dispose, and a lease's
+    downloads stay in its folder."""
 
     def __init__(self, devtools: DevToolsPipe, *, dialogs_answered: bool = False, log: Optional[BrowserLog] = None,
-                 control: Optional[BrowserControl] = None) -> None:
+                 control: Optional[BrowserControl] = None, contexts: Optional[Contexts] = None) -> None:
         self.devtools, self.dialogs_answered, self.log, self.control = devtools, dialogs_answered, log, control
+        self.contexts = contexts
         self.connections: list[dict] = []
         self._by_session: dict[str, _Connection] = {}
         self._open: set[_Connection] = set()
@@ -315,6 +325,7 @@ async def serve(self, websocket: WebSocket, user: str) -> None:
             await asyncio.gather(*connection.commands, sending, return_exceptions=True)
             with contextlib.suppress(Exception):
                 await self.devtools.call("Target.detachFromTarget", {"sessionId": session})
+            self._detached(connection)
 
     def ended(self) -> None:
         """The browser has gone: every connection is closed with a reason a client may connect again after."""
@@ -329,7 +340,7 @@ async def _command(self, connection: _Connection, message: Any) -> None:
             return
         method, params = message["method"], message.get("params") or {}
         session = message.get("sessionId") or connection.session
-        verdict = guard(method, params, dialogs_answered=self.dialogs_answered)
+        verdict = self._verdict(connection, session, method, params)
         logged = self._begin(connection, session, method, params)
         answer, guarded = {"error": {"code": SERVER_ERROR, "message": ENDED_UNANSWERED}}, None
         sending: Optional[asyncio.Future] = None
@@ -338,6 +349,8 @@ async def _command(self, connection: _Connection, message: Any) -> None:
         def reply(answer: dict) -> None:
             nonlocal replied
             replied = True
+            if sending is not None and isinstance(answer.get("result"), dict):
+                self._answered(connection, method, params, answer["result"])
             self._put(connection, _reply(message, answer))
 
         try:
@@ -373,6 +386,46 @@ def reply(answer: dict) -> None:
             if logged is not None:
                 logged.finish(answer, guarded)
 
+    def _verdict(self, connection: _Connection, session: str, method: str, params: dict) -> Verdict:
+        """The guard's verdict on ``connection``'s command, with what its contexts say: where a lease's downloads
+        go, and that only a context it made may it dispose."""
+        if self.contexts is None:
+            return guard(method, params, dialogs_answered=self.dialogs_answered)
+        if method == ENDS_CONTEXT and (reason := self.contexts.may_dispose(connection.user,
+                                                                           params.get("browserContextId"))):
+            return Verdict("refuse", params, reason)
+        download_path = None
+        if method in SETS_DOWNLOADS:
+            connection.set_downloads = True
+            context = params.get("browserContextId") if method.startswith("Browser.") else \
+                self._context_of(connection.targets.get(session))
+            download_path = self.contexts.download_path(context)
+        return guard(method, params, dialogs_answered=self.dialogs_answered, download_path=download_path)
+
+    def _context_of(self, target: Optional[str]) -> Optional[str]:
+        return self.control.tabs.get(target, {}).get("context_id") if self.control is not None and target else None
+
+    def _answered(self, connection: _Connection, method: str, params: dict, result: dict) -> None:
+        """A context ``connection`` made leased to its user before it hears the answer, and one it disposed ended."""
+        if self.contexts is None:
+            return
+        if method == MAKES_CONTEXT and isinstance(made := result.get("browserContextId"), str):
+            self.contexts.made_by_agent(connection.user, made)
+            if params.get("disposeOnDetach"):
+                connection.ends_on_detach.add(made)
+        elif method == ENDS_CONTEXT:
+            self.contexts.disposed(params.get("browserContextId"))
+
+    def _detached(self, connection: _Connection) -> None:
+        """``connection`` gone: the contexts it made to end as it detached ended, and the leases' downloads sent to
+        their folders again if it set downloads, which its session's end may set otherwise."""
+        if self.contexts is None:
+            return
+        for context in connection.ends_on_detach:
+            self.contexts.disposed(context)
+        if connection.set_downloads:
+            self.contexts.resend_downloads()
+
     def _begin(self, connection: _Connection, session: str, method: str, params: dict) -> Optional[_Logged]:
         """``connection``'s command, begun in the log, if there is one, on the tab ``session`` is on, or for a browser
         command the tab it names, ``for`` the tool calls of its user's open now; what it causes made known to the
diff --git a/packages/agentenv-protocol/src/agentenv_protocol/website_browser/contexts.py b/packages/agentenv-protocol/src/agentenv_protocol/website_browser/contexts.py
new file mode 100644
index 000000000..6cbb95514
--- /dev/null
+++ b/packages/agentenv-protocol/src/agentenv_protocol/website_browser/contexts.py
@@ -0,0 +1,237 @@
+"""The contexts a website browser leases beside its default one: each a browser context with its own cookies, local
+storage, tabs and downloads folder, named by a label, granted to the agents a task or the relay names, and ended by its
+release, a reset or the browser's relaunch, which no context outlives. A context an agent makes over CDP is leased to
+that agent as ``agent-<user>-<n>``; one made unseen, ``agent-unknown-<n>``, to nobody. Grants are recorded, not
+enforced: the CDP addresses agents hold still see every context."""
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import logging
+import re
+import shutil
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING, Callable, Optional
+
+from ..computer.errors import InvalidArgument, TargetUnavailable
+from .control import DOWNLOADS
+from .devtools import DevToolsError
+
+if TYPE_CHECKING:
+    from .control import BrowserControl
+    from .devtools import DevToolsPipe
+
+logger = logging.getLogger(__name__)
+
+#: Where each lease's files are under the session user's home, a folder per label.
+CONTEXTS = "Contexts"
+#: Who made a lease: the task, through ``contexts/lease``; else the agent that made it over CDP, by its user, or
+#: ``UNKNOWN`` for one made where the relay didn't see.
+TASK, UNKNOWN = "task", "unknown"
+#: How the labels of contexts agents make start, which a task's labels may not.
+AGENT_PREFIX = "agent-"
+#: The longest label, so ``chromium-<label>`` stays a short name.
+LABEL_CHARS = 40
+_LABEL = re.compile(r"[a-z0-9](?:[a-z0-9-]*[a-z0-9])?")
+
+
+def label_problem(label: object, *, by_task: bool = True) -> Optional[str]:
+    """Why ``label`` can't name a lease, or None: lowercase letters, digits and ``-``, not at either end, at most
+    ``LABEL_CHARS`` of them; a task's may not start ``agent-``, which names the contexts agents make."""
+    if not isinstance(label, str) or len(label) > LABEL_CHARS or not _LABEL.fullmatch(label):
+        return (f"a context's label is lowercase letters, digits and '-', not at either end, at most {LABEL_CHARS} "
+                f"characters, not {label!r}")
+    if by_task and label.startswith(AGENT_PREFIX):
+        return f"a label starting {AGENT_PREFIX!r} names a context an agent made, so a task's can't: {label!r}"
+    return None
+
+
+@dataclass
+class Lease:
+    """A leased context: its ``label``, the browser's ``id`` for it, who made it and the agents it's granted to."""
+
+    label: str
+    id: str
+    made_by: str = TASK
+    grants: list[str] = field(default_factory=list)
+
+    def folder(self, home: Path) -> Path:
+        return home / CONTEXTS / self.label
+
+    def under(self) -> str:
+        """Its downloads folder's path under the home."""
+        return f"{CONTEXTS}/{self.label}/{DOWNLOADS}"
+
+    def downloads(self, home: Path) -> Path:
+        return home / self.under()
+
+    def record(self) -> dict:
+        return {"context": self.label, "id": self.id, "made_by": self.made_by, "grants": list(self.grants)}
+
+
+class Contexts:
+    """A browser's leases by label, in memory, since a server that restarts relaunches the browser and so ends them
+    all, and what leasing, releasing and recording them does over its pipe ``devtools``. ``control`` follows each
+    context's tabs, storage and downloads; ``home`` is the session user's home."""
+
+    def __init__(self, devtools: DevToolsPipe, control: BrowserControl,
+                 home: Callable[[], Path] = Path.home) -> None:
+        self.devtools, self.control, self.home = devtools, control, home
+        self.leases: dict[str, Lease] = {}
+        self._made: dict[str, int] = {}
+        self._tasks: set[asyncio.Future] = set()
+        self._lock = asyncio.Lock()
+
+    def __iter__(self):
+        return iter(list(self.leases.values()))
+
+    def get(self, label: str) -> Optional[Lease]:
+        return self.leases.get(label)
+
+    def of(self, context_id: Optional[str]) -> Optional[Lease]:
+        return next((lease for lease in self.leases.values() if lease.id == context_id), None) \
+            if context_id else None
+
+    def id_of(self, label: Optional[str]) -> Optional[str]:
+        """The browser's id for the lease ``label``, None for the default context; TargetUnavailable for a label that
+        isn't leased."""
+        if label is None:
+            return None
+        if (lease := self.leases.get(label)) is None:
+            raise TargetUnavailable(f"no context {label!r} is leased; contexts/list names the leased ones")
+        return lease.id
+
+    async def lease(self, label: str, *, made_by: str = TASK, grants: tuple[str, ...] = ()) -> Lease:
+        """The lease ``label``: the one leased under it before, as a retried step finds it, else a new context, its
+        downloads going to its own folder. A task's label is checked; one ``made_by`` an agent may start ``agent-``,
+        as a load of a snapshot restores such leases."""
+        if problem := label_problem(label, by_task=made_by == TASK):
+            raise InvalidArgument(problem)
+        async with self._lock:
+            if (lease := self.leases.get(label)) is None:
+                context_id = (await self.devtools.call("Target.createBrowserContext", {"disposeOnDetach": False}))[
+                    "browserContextId"]
+                lease = self._record(Lease(label, context_id, made_by))
+                await self._send_downloads(lease)
+        for user in grants:
+            self.grant(label, user)
+        return lease
+
+    def grant(self, label: str, user: str) -> Lease:
+        """The lease ``label`` granted to ``user`` too, recorded; granting a user twice changes nothing."""
+        if not isinstance(user, str) or not user:
+            raise InvalidArgument("a grant names the agent's user, a non-empty string")
+        if (lease := self.leases.get(label)) is None:
+            raise TargetUnavailable(f"no context {label!r} is leased; contexts/list names the leased ones")
+        if user not in lease.grants:
+            lease.grants.append(user)
+        return lease
+
+    async def release(self, label: str) -> bool:
+        """The lease ``label`` ended: its context disposed, which closes its tabs, and its folder deleted. Whether
+        there was one: releasing a label that isn't leased does nothing, so a retried step is harmless."""
+        async with self._lock:
+            if (lease := self.leases.pop(label, None)) is None:
+                return False
+            self.control.closing_context(lease.id)
+            with contextlib.suppress(DevToolsError):
+                await self.devtools.call("Target.disposeBrowserContext", {"browserContextId": lease.id})
+            await asyncio.to_thread(shutil.rmtree, lease.folder(self.home()), True)
+        return True
+
+    def made_by_agent(self, user: str, context_id: str) -> Lease:
+        """The context ``context_id`` an agent made over CDP as ``user``, leased to it as ``agent-<user>-<n>``,
+        starting empty, its downloads sent to its own folder."""
+        if (known := self.of(context_id)) is not None:
+            return known
+        lease = self._record(Lease(self._agent_label(user), context_id, user, [user]))
+        self._spawn(self._send_downloads(lease))
+        return lease
+
+    async def find_unseen(self) -> list[Lease]:
+        """Each context the browser has that no lease names, made where the relay didn't see, leased to nobody as
+        ``agent-unknown-<n>``; the leases it made."""
+        try:
+            ids = (await self.devtools.call("Target.getBrowserContexts"))["browserContextIds"]
+        except (ConnectionError, DevToolsError, KeyError):
+            return []
+        found = []
+        for context_id in ids:
+            if self.of(context_id) is None:
+                found.append(self._record(Lease(self._agent_label(UNKNOWN), context_id, UNKNOWN)))
+                await self._send_downloads(found[-1])
+        return found
+
+    def may_dispose(self, user: str, context_id: Optional[str]) -> Optional[str]:
+        """Why an agent ``user`` may not dispose the context ``context_id``, or None: only a context it made ends
+        that way; a task's lease ends by its release, and another agent's isn't its to end."""
+        lease = self.of(context_id)
+        if lease is None or lease.made_by == user:
+            return None
+        return (f"the context {lease.label!r} is the task's, which ends by its release" if lease.made_by == TASK else
+                f"the context {lease.label!r} is another agent's")
+
+    def disposed(self, context_id: Optional[str]) -> None:
+        """The context ``context_id`` an agent disposed: its lease ended and its folder deleted."""
+        if (lease := self.of(context_id)) is not None:
+            self.leases.pop(lease.label, None)
+            self._spawn(asyncio.to_thread(shutil.rmtree, lease.folder(self.home()), True))
+
+    def download_path(self, context_id: Optional[str]) -> Optional[str]:
+        """Where the lease of the context ``context_id`` saves downloads, None for the default context or one that
+        isn't leased."""
+        lease = self.of(context_id)
+        return str(lease.downloads(self.home())) if lease is not None else None
+
+    def holding(self, path: str) -> Optional[str]:
+        """The browser's id for the lease whose downloads folder holds ``path``, None for any other path."""
+        home = self.home()
+        return next((lease.id for lease in self.leases.values() if Path(path).is_relative_to(lease.downloads(home))),
+                    None)
+
+    def resend_downloads(self) -> None:
+        """Each lease's downloads sent to its own folder again, as an agent's session that set them may leave them
+        set otherwise as it ends."""
+        for lease in self:
+            self._spawn(self._send_downloads(lease))
+
+    def ended(self) -> None:
+        """The browser has gone, and every context with it: no lease is left, and their folders are deleted."""
+        self.leases.clear()
+        self._made.clear()
+        shutil.rmtree(self.home() / CONTEXTS, ignore_errors=True)
+
+    def _record(self, lease: Lease) -> Lease:
+        self.leases[lease.label] = lease
+        self.control.other_contexts[lease.id] = lease.label
+        lease.downloads(self.home()).mkdir(parents=True, exist_ok=True)
+        return lease
+
+    def _agent_label(self, user: str) -> str:
+        """The label of the next context ``user`` makes: ``agent-<user>-<n>``, its user lowercased, each run of
+        other characters a ``-``, and cut to fit."""
+        name = re.sub(r"[^a-z0-9]+", "-", user.lower()).strip("-") or UNKNOWN
+        while True:
+            self._made[name] = self._made.get(name, 0) + 1
+            tail = f"-{self._made[name]}"
+            label = f"{AGENT_PREFIX}{name[:LABEL_CHARS - len(AGENT_PREFIX) - len(tail)].rstrip('-')}{tail}"
+            if label not in self.leases:
+                return label
+
+    async def _send_downloads(self, lease: Lease) -> None:
+        """The lease's downloads sent to its own folder, which reports them on agentenv's connection."""
+        with contextlib.suppress(ConnectionError, DevToolsError):
+            await self.devtools.call("Browser.setDownloadBehavior", {
+                "behavior": "allow", "browserContextId": lease.id, "downloadPath": str(lease.downloads(self.home())),
+                "eventsEnabled": True})
+
+    def _spawn(self, work) -> None:
+        task = asyncio.ensure_future(work)
+        self._tasks.add(task)
+        task.add_done_callback(self._finished)
+
+    def _finished(self, task: asyncio.Future) -> None:
+        self._tasks.discard(task)
+        if not task.cancelled() and (error := task.exception()) is not None:
+            logger.warning(f"the browser's contexts: {type(error).__name__}: {error}")
diff --git a/packages/agentenv-protocol/src/agentenv_protocol/website_browser/control.py b/packages/agentenv-protocol/src/agentenv_protocol/website_browser/control.py
index f8371b997..f2b041ba5 100644
--- a/packages/agentenv-protocol/src/agentenv_protocol/website_browser/control.py
+++ b/packages/agentenv-protocol/src/agentenv_protocol/website_browser/control.py
@@ -117,9 +117,17 @@ def __init__(self, devtools: DevToolsPipe, dialogs: str, viewport: Optional[tupl
         #: of agentenv's own pages whose requests it answers itself.
         self.origins: set[str] = set()
         self._serving: set[str] = set()
+        #: Every context the browser has had but its default one, by its id, with its lease's label, as agentenv
+        #: leased or recorded them, which keeps their tabs, origins and downloads out of the default context's after
+        #: they end; each one's origins seen, and the tab agentenv last brought to the front in it.
+        self.other_contexts: dict[str, str] = {}
+        self.context_origins: dict[str, set[str]] = {}
+        self._context_fronts: dict[str, str] = {}
         #: The browser's log, where its tab events go, and the commands in flight that cause them.
         self.log: Optional[BrowserLog] = None
         self.causes = Causes()
+        #: Which other context's downloads folder a path is in, as the browser's contexts tell it.
+        self.download_folders: Optional[Callable[[str], Optional[str]]] = None
         self._launching = False
         devtools.listen(self._event)
 
@@ -217,20 +225,44 @@ def _acted_on(self, target: Optional[str]) -> None:
         if actor.get("acts") and self.log is not None and self.log.last_acting.get(target, 0) < actor["seq"]:
             self.log.last_acting[target] = actor["seq"]
 
-    async def tab_list(self) -> list[dict]:
-        """The open tabs in opened order, each with its URL and title now and whether it's active."""
-        await self._refresh()
-        active = await self.active_tab()
-        return [OpenTab(**tab, active=tab["id"] == active).model_dump() for tab in self.tabs.values()]
+    def in_context(self, context_id: Optional[str], wanted: Optional[str]) -> bool:
+        """Whether something of the browser context ``context_id`` is the context ``wanted``'s: a leased one's own,
+        else the default context's, which has whatever no other context does."""
+        return context_id == wanted if wanted else context_id not in self.other_contexts
 
-    async def open_tab(self, url: Optional[str] = None, background: bool = False) -> str:
-        """A new tab at ``url``, else blank, brought to the front, or with ``background`` behind the active tab, which
-        stays active, brought back only if the new tab took its place; its id. Alone, it opens blank and goes to
-        ``url`` once it's held to the window's size, so its page loads at that size."""
-        active = await self.active_tab() if background else None
+    async def tab_list(self, context: Optional[str] = None, *, every: bool = False) -> list[dict]:
+        """The open tabs of the context ``context``, the browser's id for a leased one, else of the default context,
+        or with ``every`` of all of them, in opened order, each with its URL and title now and whether it's its
+        context's active tab."""
+        await self._refresh()
+        if every:
+            active = {await self.active_tab(wanted) for wanted in [None, *self.context_ids()]}
+            return [OpenTab(**tab, active=tab["id"] in active, context=self.label_of(tab)).model_dump()
+                    for tab in self.tabs.values()]
+        active = await self.active_tab(context)
+        return [OpenTab(**tab, active=tab["id"] == active, context=self.label_of(tab)).model_dump()
+                for tab in self.tabs.values() if self.in_context(tab.get("context_id"), context)]
+
+    def label_of(self, entry: dict) -> Optional[str]:
+        """The label of the lease a tab or download was in, None for the default context."""
+        return self.other_contexts.get(entry.get("context_id"))
+
+    def context_ids(self) -> list[str]:
+        """The other contexts with a tab open now, in the order their first opened."""
+        return list(dict.fromkeys(tab["context_id"] for tab in self.tabs.values()
+                                  if tab.get("context_id") in self.other_contexts))
+
+    async def open_tab(self, url: Optional[str] = None, background: bool = False,
+                       context: Optional[str] = None) -> str:
+        """A new tab at ``url``, else blank, in the context ``context``, the browser's id for a leased one, else the
+        default, brought to the front, or with ``background`` behind its context's active tab, which stays active,
+        brought back only if the new tab took its place; its id. Alone, it opens blank and goes to ``url`` once it's
+        held to the window's size, so its page loads at that size."""
+        active = await self.active_tab(context) if background else None
         held = self.viewport is not None and url
         start = "about:blank" if held else url or "about:blank"
-        target = await self.create_target({"url": start, "background": background})
+        target = await self.create_target({"url": start, "background": background,
+                                           **({"browserContextId": context} if context else {})})
         self._acted_on(target)
         if held:
             await asyncio.wait_for(self._pinned.setdefault(target, asyncio.Event()).wait(), PIN_TIMEOUT_S)
@@ -238,7 +270,7 @@ async def open_tab(self, url: Optional[str] = None, background: bool = False) ->
             await self._navigate(target, "Page.navigate", {"url": url}, session)
         if not background:
             await self._bring_to_front(target)
-        elif active is not None and active in self.tabs and await self.active_tab() == target:
+        elif active is not None and active in self.tabs and await self.active_tab(context) == target:
             await self._bring_to_front(active)
         return target
 
@@ -253,7 +285,8 @@ async def load_start_tabs(self, urls: list[str], site_of: Callable[[str], Option
         shows it only once it loads again."""
         if not urls:
             return []
-        targets = list(self.tabs)[:len(urls)] or [await self._first_tab()]
+        targets = [target for target, tab in self.tabs.items()
+                   if self.in_context(tab.get("context_id"), None)][:len(urls)] or [await self._first_tab()]
         while len(targets) < len(urls):
             targets.append(await self.create_target({"url": "about:blank", "background": True}))
         for target in targets:
@@ -323,11 +356,12 @@ async def _settled(self, target: str, load: _StartLoad, timeout_s: float) -> dic
                         load_ms=round((asyncio.get_running_loop().time() - load.started) * 1000), site=load.site,
                         outcome=outcome).model_dump()
 
-    async def replace_tabs(self, tabs: list) -> None:
-        """``tabs``, each with its ``url`` and whether it's ``active``, opened in order in place of the tabs open now,
-        the active one, else the first, in front. The new ones open before the old close, so the window stays."""
-        before = list(self.tabs)
-        opened = [await self.open_tab(tab.url) for tab in tabs]
+    async def replace_tabs(self, tabs: list, context: Optional[str] = None) -> None:
+        """``tabs``, each with its ``url`` and whether it's ``active``, opened in order in place of the tabs open now
+        in the context ``context``, else the default one, the active one, else the first, in front. The new ones open
+        before the old close, so the window stays."""
+        before = [target for target, tab in self.tabs.items() if self.in_context(tab.get("context_id"), context)]
+        opened = [await self.open_tab(tab.url, context=context) for tab in tabs]
         for target in before:
             await self.close_tab(target)
         if opened:
@@ -340,19 +374,31 @@ def forget(self) -> None:
         self.closed_tabs, self.dialog_log = [], []
         self.downloads.clear()
         self.origins.clear()
-
-    async def activate(self, target: str) -> None:
-        """The open tab ``target`` brought to the front, the active one."""
-        self._open(target)
+        self.context_origins.clear()
+        self._context_fronts.clear()
+        self.other_contexts.clear()
+
+    async def activate(self, target: str, context: Optional[str] = None) -> None:
+        """The open tab ``target`` of the context ``context``, else of the default one, brought to the front, its
+        context's active one."""
+        self._open(target, context)
         self._acted_on(target)
         await self._bring_to_front(target)
 
-    async def close(self, target: str) -> None:
-        """The open tab ``target`` closed, which the record says agentenv closed."""
-        self._open(target)
+    async def close(self, target: str, context: Optional[str] = None) -> None:
+        """The open tab ``target`` of the context ``context``, else of the default one, closed, which the record says
+        agentenv closed."""
+        self._open(target, context)
         self._acted_on(target)
         await self.close_tab(target)
 
+    def closing_context(self, context: str) -> None:
+        """The context ``context`` about to end, its tabs closing with it, which the record says agentenv closed."""
+        for target, tab in self.tabs.items():
+            if tab.get("context_id") == context:
+                self._closing.add(target)
+                self.causes.closing(target, _cause())
+
     async def navigate(self, url: str) -> None:
         """The active tab opened at ``url``; InvalidArgument, with the browser's reason, when it can't."""
         session = await self.active_session()
@@ -441,23 +487,28 @@ def _state_of(self, target: str) -> dict:
             state["file_chooser"] = {"multiple": chooser["multiple"]}
         return state
 
-    def _open(self, target: str) -> None:
-        if target not in self.tabs:
-            raise InvalidArgument(f"no tab {target} is open; list the tabs for their ids")
+    def _open(self, target: str, context: Optional[str] = None) -> None:
+        if target not in self.tabs or not self.in_context(self.tabs[target].get("context_id"), context):
+            raise InvalidArgument(f"no tab {target} is open in that context; list its tabs for their ids" if context
+                                  else f"no tab {target} is open; list the tabs for their ids")
 
     async def _bring_to_front(self, target: str) -> None:
         await self.devtools.call("Target.activateTarget", {"targetId": target})
         if (session := next((s for s, t in self._sessions.items() if t == target), None)) is not None:
             with contextlib.suppress(DevToolsError):
                 await self.devtools.call("Page.bringToFront", session_id=session)
-        self._front = target
+        if (context := self.tabs.get(target, {}).get("context_id")) in self.other_contexts:
+            self._context_fronts[context] = target
+        else:
+            self._front = target
 
     @contextlib.asynccontextmanager
-    async def hidden_page(self, url: str = "about:blank") -> AsyncIterator[str]:
-        """A page of agentenv's own for reading state, in no window and never in the record; its session's id. It's
-        closed after."""
-        target = (await self.devtools.call("Target.createTarget",
-                                           {"url": url, "hidden": True, "background": True}))["targetId"]
+    async def hidden_page(self, url: str = "about:blank", context: Optional[str] = None) -> AsyncIterator[str]:
+        """A page of agentenv's own for reading state, in the context ``context``, else the default one, in no window
+        and never in the record; its session's id. It's closed after."""
+        target = (await self.devtools.call("Target.createTarget", {
+            "url": url, "hidden": True, "background": True,
+            **({"browserContextId": context} if context else {})}))["targetId"]
         self._hidden.add(target)
         self.tabs.pop(target, None)
         try:
@@ -466,15 +517,17 @@ async def hidden_page(self, url: str = "about:blank") -> AsyncIterator[str]:
             with contextlib.suppress(ConnectionError, DevToolsError):
                 await self.devtools.call("Target.closeTarget", {"targetId": target})
 
-    async def active_tab(self) -> Optional[str]:
-        """The tab a dialog is open on, whose page it blocks from saying; else the visible tab whose page has focus, as
-        a hidden tab's page that had input still says it has; else the one agentenv last brought to the front, else the
-        first visible one: CDP has no event for a tab made active."""
-        if dialogs := [dialog["tab"] for dialog in self._open_dialogs.values() if dialog["tab"] in self.tabs]:
+    async def active_tab(self, context: Optional[str] = None) -> Optional[str]:
+        """The active tab of the context ``context``, else of the default one: the tab a dialog is open on, whose page
+        it blocks from saying; else the visible tab whose page has focus, as a hidden tab's page that had input still
+        says it has; else the one agentenv last brought to the front, else the first visible one: CDP has no event for
+        a tab made active."""
+        ours = {target for target, tab in self.tabs.items() if self.in_context(tab.get("context_id"), context)}
+        if dialogs := [dialog["tab"] for dialog in self._open_dialogs.values() if dialog["tab"] in ours]:
             return dialogs[-1]
         visible = None
         for session, target in list(self._sessions.items()):
-            if target not in self.tabs:
+            if target not in ours:
                 continue
             try:
                 state = (await self.devtools.call(
@@ -487,39 +540,42 @@ async def active_tab(self) -> Optional[str]:
                 return target
             if state[0] == "visible" and visible is None:
                 visible = target
-        return self._front if self._front in self.tabs else visible
+        front = self._context_fronts.get(context) if context else self._front
+        return front if front in ours else visible
 
     async def record(self) -> dict:
         """The record ``since`` it started: open ``tabs``, each with its URL and title now and whether it's ``active``,
         ``closed_tabs``, ``downloads`` and ``dialogs``."""
-        return {"since": self.since, "tabs": await self.tab_list(),
-                "closed_tabs": [ClosedTab(**tab).model_dump() for tab in self.closed_tabs],
-                "downloads": self.download_list(), "dialogs": [Dialog(**dialog).model_dump() for dialog in self.dialog_log]}
+        return {"since": self.since, "tabs": await self.tab_list(every=True),
+                "closed_tabs": [ClosedTab(**tab, context=self.label_of(tab)).model_dump() for tab in self.closed_tabs],
+                "downloads": self.download_list(every=True), "dialogs": [Dialog(**dialog).model_dump() for dialog in self.dialog_log]}
 
-    async def cookies(self, urls: Optional[list[str]] = None) -> list[dict]:
-        """The default context's cookies, or those a request to any of ``urls`` would send, as Playwright picks them."""
+    async def cookies(self, urls: Optional[list[str]] = None, context: Optional[str] = None) -> list[dict]:
+        """The cookies of the context ``context``, the browser's id for a leased one, else of the default context, or
+        those a request to any of ``urls`` would send, as Playwright picks them."""
         cookies = [Cookie(**{field: raw[field] for field in Cookie.model_fields if field in raw})
-                   for raw in (await self.devtools.call("Storage.getCookies"))["cookies"]]
+                   for raw in (await self.devtools.call("Storage.getCookies", _in(context)))["cookies"]]
         return [cookie.model_dump(exclude_none=True) for cookie in cookies
                 if not urls or any(_sent(cookie, url) for url in urls)]
 
-    async def set_cookies(self, cookies: list[CookieToSet]) -> None:
-        """``cookies`` set in the default context at once, a ``max_age`` turned into an expiry on this machine's clock,
-        which the browser's cookies are judged by; InvalidArgument when the browser refuses one, which sets none."""
+    async def set_cookies(self, cookies: list[CookieToSet], context: Optional[str] = None) -> None:
+        """``cookies`` set at once in the context ``context``, else the default one, a ``max_age`` turned into an
+        expiry on this machine's clock, which the browser's cookies are judged by; InvalidArgument when the browser
+        refuses one, which sets none."""
         try:
             await self.devtools.call("Storage.setCookies", {"cookies": [_cdp_cookie(cookie, time.time())
-                                                                        for cookie in cookies]})
+                                                                        for cookie in cookies], **_in(context)})
         except DevToolsError as e:
             raise InvalidArgument(f"the browser refused the cookies, so it set none of them: {e}")
 
     async def delete_cookies(self, name: Optional[str] = None, domain: Optional[str] = None,
-                             path: Optional[str] = None) -> int:
-        """Every cookie of the default context with all of ``name``, ``domain`` and ``path`` given, every cookie with
-        none given, deleted; how many."""
-        gone = [cookie for cookie in await self.cookies() if (name is None or cookie["name"] == name)
+                             path: Optional[str] = None, context: Optional[str] = None) -> int:
+        """Every cookie of the context ``context``, else of the default one, with all of ``name``, ``domain`` and
+        ``path`` given, every cookie with none given, deleted; how many."""
+        gone = [cookie for cookie in await self.cookies(context=context) if (name is None or cookie["name"] == name)
                 and (domain is None or cookie["domain"] == domain) and (path is None or cookie["path"] == path)]
         if gone:
-            async with self.hidden_page() as session:
+            async with self.hidden_page(context=context) as session:
                 for cookie in gone:
                     await self.devtools.call("Network.deleteCookies", {
                         "name": cookie["name"], "domain": cookie["domain"], "path": cookie["path"],
@@ -527,11 +583,14 @@ async def delete_cookies(self, name: Optional[str] = None, domain: Optional[str]
                         session_id=session)
         return len(gone)
 
-    async def local_storage(self, origins: Optional[list[str]] = None) -> list[dict]:
-        """The local storage of each of ``origins``, else of every origin it has seen, as ``storageState`` has it."""
-        wanted = _origins(origins) if origins is not None else sorted(self.origins)
-        found = []
-        async with self._at_origins() as visit:
+    async def local_storage(self, origins: Optional[list[str]] = None, context: Optional[str] = None) -> list[dict]:
+        """The local storage of the context ``context``, else of the default one, of each of ``origins``, else of
+        every origin it has seen there, as ``storageState`` has it."""
+        wanted = _origins(origins) if origins is not None else sorted(self.origins_of(context))
+        found: list[dict] = []
+        if not wanted:
+            return found
+        async with self._at_origins(context) as visit:
             for asked in wanted:
                 session, origin = await visit(asked)
                 entries = (await self.devtools.call("DOMStorage.getDOMStorageItems", {"storageId": _storage(origin)},
@@ -540,41 +599,59 @@ async def local_storage(self, origins: Optional[list[str]] = None) -> list[dict]
                                                                         for name, value in entries]).model_dump())
         return found
 
-    async def set_local_storage(self, origins: list[OriginStorage]) -> None:
-        """Each origin's items set in its local storage, beside those it has."""
-        async with self._at_origins() as visit:
+    async def set_local_storage(self, origins: list[OriginStorage], context: Optional[str] = None) -> None:
+        """Each origin's items set in its local storage in the context ``context``, else the default one, beside
+        those it has."""
+        if not origins:
+            return
+        async with self._at_origins(context) as visit:
             for origin in origins:
                 session, named = await visit(origin.origin)
                 for item in origin.localStorage:
                     await self.devtools.call("DOMStorage.setDOMStorageItem", {
                         "storageId": _storage(named), "key": item.name, "value": item.value}, session_id=session)
 
-    async def clear_local_storage(self, origins: Optional[list[str]] = None) -> list[str]:
-        """The local storage of each of ``origins``, else of every origin it has seen, cleared; those origins."""
-        wanted, cleared = _origins(origins) if origins is not None else sorted(self.origins), []
-        async with self._at_origins() as visit:
+    async def clear_local_storage(self, origins: Optional[list[str]] = None,
+                                  context: Optional[str] = None) -> list[str]:
+        """The local storage of the context ``context``, else of the default one, of each of ``origins``, else of
+        every origin it has seen there, cleared; those origins."""
+        wanted = _origins(origins) if origins is not None else sorted(self.origins_of(context))
+        cleared: list[str] = []
+        if not wanted:
+            return cleared
+        async with self._at_origins(context) as visit:
             for asked in wanted:
                 session, origin = await visit(asked)
                 await self.devtools.call("DOMStorage.clear", {"storageId": _storage(origin)}, session_id=session)
                 cleared.append(origin)
         return cleared
 
-    def download_list(self) -> list[dict]:
-        return [Download(**download).model_dump() for download in self.downloads.values()]
+    def download_list(self, context: Optional[str] = None, *, every: bool = False) -> list[dict]:
+        """The downloads of the context ``context``, else of the default one, or with ``every`` of all of them."""
+        return [Download(**download, context=self.label_of(download)).model_dump()
+                for download in self.downloads.values()
+                if every or self.in_context(download.get("context_id"), context)]
+
+    def download(self, guid: str, context: Optional[str] = None) -> dict:
+        """The download ``guid`` of the context ``context``, else of the default one; InvalidArgument for one it
+        hasn't seen there."""
+        if guid not in self.downloads or not self.in_context(self.downloads[guid].get("context_id"), context):
+            raise InvalidArgument(f"no download {guid} has begun in that context; list its downloads for their guids"
+                                  if context else f"no download {guid} has begun; list the downloads for their guids")
+        return Download(**self.downloads[guid], context=self.label_of(self.downloads[guid])).model_dump()
 
-    def download(self, guid: str) -> dict:
-        """The download ``guid``; InvalidArgument for one it hasn't seen."""
-        if guid not in self.downloads:
-            raise InvalidArgument(f"no download {guid} has begun; list the downloads for their guids")
-        return Download(**self.downloads[guid]).model_dump()
+    def origins_of(self, context: Optional[str]) -> set[str]:
+        """The origins seen in the context ``context``, the browser's id for a leased one, else in the default one."""
+        return self.context_origins.setdefault(context, set()) if context else self.origins
 
     @contextlib.asynccontextmanager
-    async def _at_origins(self) -> AsyncIterator[Callable[[str], Awaitable[tuple[str, str]]]]:
+    async def _at_origins(self, context: Optional[str] = None
+                          ) -> AsyncIterator[Callable[[str], Awaitable[tuple[str, str]]]]:
         """A page of agentenv's own, ``visit``, that goes to an origin and returns its session and the origin as the
         browser names it, once it's that origin's page. agentenv serves it the document, and a service worker of the
         origin is bypassed, so the site gets no request and runs no script: CDP reaches an origin's local storage only
         through a page of that origin."""
-        async with self.hidden_page() as session:
+        async with self.hidden_page(context=context) as session:
             self._serving.add(session)
             try:
                 await self.devtools.call("Network.enable", session_id=session)
@@ -593,7 +670,7 @@ async def visit(origin: str) -> tuple[str, str]:
                         if asyncio.get_running_loop().time() > deadline:
                             raise DeviceUnavailable(f"a page of {origin} didn't open within {PIN_TIMEOUT_S:g} s")
                         await asyncio.sleep(ARRIVAL_POLL_S)
-                    self.origins.add(named)
+                    self.origins_of(context).add(named)
                     return session, named
 
                 yield visit
@@ -602,7 +679,8 @@ async def visit(origin: str) -> tuple[str, str]:
 
     async def active_session(self) -> str:
         """The session of the active tab, else of the first open one; DeviceUnavailable with no tab open."""
-        active = await self.active_tab() or next(iter(self.tabs), None)
+        active = await self.active_tab() or next((target for target, tab in self.tabs.items()
+                                                  if self.in_context(tab.get("context_id"), None)), None)
         session = next((session for session, target in self._sessions.items() if target == active), None)
         if session is None:
             raise DeviceUnavailable("the browser has no tab open")
@@ -754,8 +832,8 @@ def _on_Target_targetCreated(self, params: dict, session: Optional[str]) -> None
         if info.get("type") == "page" and info["targetId"] not in self._hidden and info["targetId"] not in self.tabs:
             self.tabs[info["targetId"]] = {"id": info["targetId"], "url": info.get("url", ""),
                                            "title": info.get("title", ""), "opened_at": _now(),
-                                           "opener": info.get("openerId")}
-            self._saw(info.get("url", ""))
+                                           "opener": info.get("openerId"), "context_id": info.get("browserContextId")}
+            self._saw(info.get("url", ""), info.get("browserContextId"))
             if self.log is not None:
                 self._spawn(self._log_opened(self.log.reserve(), log_time(), info["targetId"], info.get("url", ""),
                                              info.get("openerId"), self._launching))
@@ -789,11 +867,12 @@ def _on_Target_targetInfoChanged(self, params: dict, session: Optional[str]) ->
         info = params["targetInfo"]
         if (tab := self.tabs.get(info["targetId"])) is not None:
             tab.update(url=info.get("url", tab["url"]), title=info.get("title", tab["title"]))
-            self._saw(tab["url"])
+            self._saw(tab["url"], tab.get("context_id"))
 
     def _on_Page_frameNavigated(self, params: dict, session: Optional[str]) -> None:
         if session in self._sessions:
-            self._saw(params.get("frame", {}).get("url", ""))
+            self._saw(params.get("frame", {}).get("url", ""),
+                      self.tabs.get(self._sessions[session], {}).get("context_id"))
         frame = params.get("frame", {})
         if not frame.get("parentId") and (target := self._sessions.get(session)) is not None:
             self._page_loading.add(target)
@@ -834,9 +913,9 @@ def _on_Fetch_requestPaused(self, params: dict, session: Optional[str]) -> None:
                 "responseHeaders": [{"name": "Content-Type", "value": "text/html"}], "body": SERVED_PAGE},
                 session_id=session))
 
-    def _saw(self, url: str) -> None:
+    def _saw(self, url: str, context: Optional[str] = None) -> None:
         if (origin := origin_of(url)) is not None:
-            self.origins.add(origin)
+            self.origins_of(context if context in self.other_contexts else None).add(origin)
 
     def _on_Target_targetDestroyed(self, params: dict, session: Optional[str]) -> None:
         target = params["targetId"]
@@ -922,7 +1001,8 @@ def _on_Page_javascriptDialogClosed(self, params: dict, session: Optional[str])
     def _on_Browser_downloadWillBegin(self, params: dict, session: Optional[str]) -> None:
         self.downloads[params["guid"]] = {"guid": params["guid"], "url": params.get("url", ""),
                                           "filename": params.get("suggestedFilename", ""), "state": "inProgress",
-                                          "started_at": _now()}
+                                          "started_at": _now(),
+                                          "context_id": self.tabs.get(params.get("frameId"), {}).get("context_id")}
 
     def _on_Browser_downloadProgress(self, params: dict, session: Optional[str]) -> None:
         if (download := self.downloads.get(params["guid"])) is None:
@@ -933,10 +1013,17 @@ def _on_Browser_downloadProgress(self, params: dict, session: Optional[str]) ->
                 download["ended_at"] = _now()
                 return
             download["path"] = params["filePath"]
+            if (context := self.saved_in(params["filePath"])) is not None:
+                download["context_id"] = context
             self._spawn(self._hashed(download, Path(params["filePath"])))
         elif params["state"] == "canceled":
             download["ended_at"] = _now()
 
+    def saved_in(self, path: str) -> Optional[str]:
+        """The other context whose downloads folder ``path`` is in, as each lease's downloads go to their own; None
+        for any other path. Set by the browser's contexts."""
+        return self.download_folders(path) if self.download_folders is not None else None
+
     async def _hashed(self, download: dict, path: Path) -> None:
         try:
             size, sha256 = await asyncio.to_thread(_size_and_sha256, path)
@@ -1050,6 +1137,11 @@ def _origins(origins: list[str]) -> list[str]:
         raise InvalidArgument(str(e))
 
 
+def _in(context: Optional[str]) -> dict:
+    """The parameter naming the browser context ``context`` to a command, none for the default context."""
+    return {"browserContextId": context} if context else {}
+
+
 def _storage(origin: str) -> dict:
     return {"storageKey": f"{origin}/", "isLocalStorage": True}
 
diff --git a/packages/agentenv-protocol/src/agentenv_protocol/website_browser/data.py b/packages/agentenv-protocol/src/agentenv_protocol/website_browser/data.py
index a85d7ebae..d77c334a8 100644
--- a/packages/agentenv-protocol/src/agentenv_protocol/website_browser/data.py
+++ b/packages/agentenv-protocol/src/agentenv_protocol/website_browser/data.py
@@ -12,6 +12,7 @@
 from ..computer.app_data import write_within
 from ..computer.dataplane import part_bytes
 from ..types import DataPart, FilePart, uploaded_object_path
+from .contexts import CONTEXTS
 from .control import DOWNLOADS, UPLOADS
 from .network import HAR_FILE
 
@@ -32,11 +33,13 @@
 
 @dataclass
 class Load:
-    """A ``data/add``'s parts sorted by what each is: the typed state, the profile's files, and files for the folders
-    the browser downloads into and uploads from, each by its path under the home."""
+    """A ``data/add``'s parts sorted by what each is: the typed state, the profile's files, files for the folders
+    the browser downloads into and uploads from, and each lease's downloads by its label, each by its path under the
+    home."""
     state: Optional[dict] = None
     profile: dict[str, bytes] = field(default_factory=dict)
     files: dict[str, bytes] = field(default_factory=dict)
+    context_files: dict[str, dict[str, bytes]] = field(default_factory=dict)
 
 
 async def sorted_load(parts: list, profile: str) -> Load:
@@ -65,12 +68,22 @@ async def sorted_load(parts: list, profile: str) -> Load:
             load.profile[path] = await part_bytes(part)
         elif under.is_relative_to(DOWNLOADS) or under.is_relative_to(UPLOADS):
             load.files[path] = await part_bytes(part)
+        elif (label := context_of(under)) is not None:
+            load.context_files.setdefault(label, {})[path] = await part_bytes(part)
         else:
             raise ValueError(f"{path!r} is none of the browser's: its state, {STATE_FILE}, and files under its "
-                             f"profile, {profile}, ~/{DOWNLOADS} and ~/{UPLOADS}")
+                             f"profile, {profile}, ~/{DOWNLOADS}, ~/{UPLOADS} and a lease's "
+                             f"~/{CONTEXTS}/<label>/{DOWNLOADS}")
     return load
 
 
+def context_of(path: PurePosixPath) -> Optional[str]:
+    """The label of the lease whose downloads folder holds the file at ``path``, under the home; None for any other
+    path."""
+    parts = path.parts
+    return parts[1] if len(parts) > 3 and parts[0] == CONTEXTS and parts[2] == DOWNLOADS else None
+
+
 def _json(raw: bytes) -> Any:
     try:
         return json.loads(raw)
@@ -103,12 +116,13 @@ def _copied(source: Path, target: Path) -> None:
         pass
 
 
-def finished_downloads(home: Path) -> list[str]:
-    """The path under the home of each file in the downloads folder the browser has finished writing."""
-    folder = home / DOWNLOADS
+def finished_downloads(home: Path, under: str = DOWNLOADS) -> list[str]:
+    """The path under the home of each file in the downloads folder ``under`` it, ``~/Downloads`` else a lease's, the
+    browser has finished writing."""
+    folder = home / under
     if not folder.is_dir():
         return []
-    return sorted(f"{DOWNLOADS}/{path.relative_to(folder).as_posix()}" for path in folder.rglob("*")
+    return sorted(f"{under}/{path.relative_to(folder).as_posix()}" for path in folder.rglob("*")
                   if path.is_file() and not path.name.endswith(PARTIAL))
 
 
diff --git a/packages/agentenv-protocol/src/agentenv_protocol/website_browser/environment.py b/packages/agentenv-protocol/src/agentenv_protocol/website_browser/environment.py
index c83699351..c9a07b691 100644
--- a/packages/agentenv-protocol/src/agentenv_protocol/website_browser/environment.py
+++ b/packages/agentenv-protocol/src/agentenv_protocol/website_browser/environment.py
@@ -32,10 +32,12 @@
 from ..transfers import WriteNamespaceGrant
 from ..types import METHOD_ADD, RPC_PATH, EnvironmentExtension, IntakeDeclaration, IntakeFormat, intake_extension
 from . import data
+from .contexts import CONTEXTS, TASK, Contexts, label_problem
 from .control import AGENT, DOWNLOADS, EXIT, LIVE_START_TAB_TIMEOUT_S, LOADED, STOP, UPLOADS, BrowserControl, _now
 from .devtools import PIPE_IN, PIPE_OUT, DevToolsError, DevToolsPipe
 from .recording import BROWSER_RECORDING, MAX_DURATION_S, MAX_FRAMES, BrowserRecordings
-from .shapes import BrowserRecord, BrowserState, CookieToSet, OriginStorage, SiteNames, StateToLoad
+from .shapes import (BrowserRecord, BrowserState, ContextState, ContextToLoad, CookieToSet, OriginStorage, SiteNames,
+                     StateToLoad)
 
 logger = logging.getLogger(__name__)
 
@@ -84,7 +86,8 @@
 SKILL = f"""# Website browser
 
 - Open sites by their real names, such as `https://slack.com`: the environment serves its sites under those names.
-- Files to upload are in `~/{UPLOADS}`; downloads land in `~/{DOWNLOADS}`.
+- Files to upload are in `~/{UPLOADS}`; downloads land in `~/{DOWNLOADS}`, and a leased context's in
+  `~/{CONTEXTS}/<label>/{DOWNLOADS}`.
 """
 
 
@@ -156,12 +159,15 @@ def __init__(self) -> None:
         self.log = BrowserLog.for_app(os.environ.get("ENVIRONMENT_NAME") or type(self).__name__.lower(),
                                       SOCKET.parent)
         self.control.log = self.log
+        #: The contexts it leases beside its default one, which no relaunch outlives.
+        self.contexts = Contexts(self.devtools, self.control)
+        self.control.download_folders = self.contexts.holding
         #: Its network log, as the proxy it goes out through writes it; None when no proxy logs for it.
         self.network = NetworkLog(path) if (path := log_path()) is not None else None
         #: The CDP addresses it has handed out, and the relay agents' connections to them go through.
         self.cdp_tokens = Tokens(SOCKET.parent / "cdp-tokens.json")
         self.relay = Relay(self.devtools, dialogs_answered=self.settings.dialogs != AGENT, log=self.log,
-                           control=self.control)
+                           control=self.control, contexts=self.contexts)
         #: Its recordings: frames of the tab an agent last acted in, and its log, uploaded under each one's grant.
         self.recordings = BrowserRecordings(self.log, self.control)
         self.devtools.on_close(self._pipe_closed)
@@ -226,10 +232,12 @@ def _command_line_tabs(self) -> list[str]:
         return ["about:blank"]
 
     async def _launch_fds(self) -> dict[int, int]:
-        """Before each launch, an empty cache and the deploy's prompt answers in its profile; and a new debugging pipe:
-        the browser's ends as its fds 3 and 4, this server's ends its CDP connection, which follows the browser and
-        then opens the start tabs its command line can't."""
+        """Before each launch, an empty cache, no lease's folder, as a server killed with leases leaves them, and the
+        deploy's prompt answers in its profile; and a new debugging pipe: the browser's ends as its fds 3 and 4, this
+        server's ends its CDP connection, which follows the browser and then opens the start tabs its command line
+        can't."""
         shutil.rmtree(self.cache_dir(), ignore_errors=True)
+        self.contexts.ended()
         self._write_prompt_answers()
         to_browser_read, to_browser_write = os.pipe()
         from_browser_read, from_browser_write = os.pipe()
@@ -241,9 +249,10 @@ async def _launch_fds(self) -> dict[int, int]:
 
     def _pipe_closed(self) -> None:
         """The browser closed its pipe: its tabs closed by its exit when it ended on its own, else by its server's
-        stop."""
+        stop, and every lease with it."""
         self.control.ended(EXIT if self._computer_app.exited() else STOP)
         self.relay.ended()
+        self.contexts.ended()
 
     async def _follow(self, urls: list[str], at: str, launched: float) -> None:
         """Its control attached, then its start tabs at ``urls`` loaded, the launch's outcomes kept."""
@@ -329,7 +338,14 @@ async def start_tabs_loaded(self) -> bool:
         "what is open on it. cookies/get, cookies/set and cookies/delete, and local_storage/get, local_storage/set and "
         "local_storage/clear, read and change its default context's cookies and local storage as Playwright's "
         "storageState has them, a cookie's max_age set as an expiry on the browser's clock; downloads/list and "
-        "downloads/get are its downloads, get with its file, uploaded under a write_namespace grant or inline. cdp "
+        "downloads/get are its downloads, get with its file, uploaded under a write_namespace grant or inline. "
+        "contexts/lease leases a context beside the default one by a label, lowercase letters, digits and '-': its "
+        "own cookies, local storage, tabs and downloads, in ~/Contexts/<label>/Downloads, the one leased under that "
+        "label before when there is one; contexts/grant records an agent's user it's for, which nothing enforces yet; "
+        "contexts/release ends it, closing its tabs and deleting its folder; and contexts/list lists them, each with "
+        "who made it: the task, or the agent whose CDP connection made it, leased to it as agent-<user>-<n>. Naming "
+        "a lease's label as context, the tabs, cookies, local_storage and downloads ops act on that context, else on "
+        "the default one. A reset or relaunch of the browser ends every lease. cdp "
         "returns a user's CDP address, http_url to discover from and ws_url to connect to, under origin, where the "
         "caller's agent reaches the env, when it names one, else at the address the call reached the browser at, "
         "with a token agentenv mints in its path: each connection to it gets its own browser-level session behind a "
@@ -501,60 +517,88 @@ async def browser_history(self, direction: str) -> dict:
         await self.control.history(direction)
         return {}
 
+    @extension(BROWSER, op="contexts/lease")
+    async def browser_contexts_lease(self, label: str) -> dict:
+        """The context leased as ``label``: the one leased under it before, as a retried step finds it, else a new
+        one; its label and the browser's id for it."""
+        lease = await self.contexts.lease(label)
+        return {"context": lease.label, "id": lease.id}
+
+    @extension(BROWSER, op="contexts/grant")
+    async def browser_contexts_grant(self, context: str, user: str) -> dict:
+        """The lease ``context`` granted to the agent ``user`` too, recorded, not enforced; who it's granted to."""
+        lease = self.contexts.grant(context, user)
+        return {"context": lease.label, "grants": list(lease.grants)}
+
+    @extension(BROWSER, op="contexts/release")
+    async def browser_contexts_release(self, context: str) -> dict:
+        """The lease ``context`` ended, its tabs closed and its folder deleted; whether there was one."""
+        return {"released": await self.contexts.release(context)}
+
+    @extension(BROWSER, op="contexts/list", method="GET")
+    async def browser_contexts_list(self) -> dict:
+        """Every lease, a context made where agentenv didn't see leased to nobody first."""
+        await self.contexts.find_unseen()
+        return {"contexts": [lease.record() for lease in self.contexts]}
+
     @extension(BROWSER, op="tabs/list", method="GET")
-    async def browser_tabs_list(self) -> dict:
-        return {"tabs": await self.control.tab_list()}
+    async def browser_tabs_list(self, context: Optional[str] = None) -> dict:
+        return {"tabs": await self.control.tab_list(self.contexts.id_of(context))}
 
     @extension(BROWSER, op="tabs/open")
-    async def browser_tabs_open(self, url: Optional[str] = None, background: bool = False) -> dict:
-        return {"tab": await self.control.open_tab(url, background)}
+    async def browser_tabs_open(self, url: Optional[str] = None, background: bool = False,
+                                context: Optional[str] = None) -> dict:
+        return {"tab": await self.control.open_tab(url, background, self.contexts.id_of(context))}
 
     @extension(BROWSER, op="tabs/activate")
-    async def browser_tabs_activate(self, tab: str) -> dict:
-        await self.control.activate(tab)
+    async def browser_tabs_activate(self, tab: str, context: Optional[str] = None) -> dict:
+        await self.control.activate(tab, self.contexts.id_of(context))
         return {}
 
     @extension(BROWSER, op="tabs/close")
-    async def browser_tabs_close(self, tab: str) -> dict:
-        await self.control.close(tab)
+    async def browser_tabs_close(self, tab: str, context: Optional[str] = None) -> dict:
+        await self.control.close(tab, self.contexts.id_of(context))
         return {}
 
     @extension(BROWSER, op="cookies/get")
-    async def browser_cookies_get(self, urls: Optional[list[str]] = None) -> dict:
-        return {"cookies": await self.control.cookies(urls)}
+    async def browser_cookies_get(self, urls: Optional[list[str]] = None, context: Optional[str] = None) -> dict:
+        return {"cookies": await self.control.cookies(urls, self.contexts.id_of(context))}
 
     @extension(BROWSER, op="cookies/set")
-    async def browser_cookies_set(self, cookies: list[dict]) -> dict:
-        await self.control.set_cookies(_parsed(CookieToSet, cookies, "cookies"))
+    async def browser_cookies_set(self, cookies: list[dict], context: Optional[str] = None) -> dict:
+        await self.control.set_cookies(_parsed(CookieToSet, cookies, "cookies"), self.contexts.id_of(context))
         return {}
 
     @extension(BROWSER, op="cookies/delete")
     async def browser_cookies_delete(self, name: Optional[str] = None, domain: Optional[str] = None,
-                                     path: Optional[str] = None) -> dict:
-        return {"deleted": await self.control.delete_cookies(name, domain, path)}
+                                     path: Optional[str] = None, context: Optional[str] = None) -> dict:
+        return {"deleted": await self.control.delete_cookies(name, domain, path, self.contexts.id_of(context))}
 
     @extension(BROWSER, op="local_storage/get")
-    async def browser_local_storage_get(self, origins: Optional[list[str]] = None) -> dict:
-        return {"origins": await self.control.local_storage(origins)}
+    async def browser_local_storage_get(self, origins: Optional[list[str]] = None,
+                                        context: Optional[str] = None) -> dict:
+        return {"origins": await self.control.local_storage(origins, self.contexts.id_of(context))}
 
     @extension(BROWSER, op="local_storage/set")
-    async def browser_local_storage_set(self, origins: list[dict]) -> dict:
-        await self.control.set_local_storage(_parsed(OriginStorage, origins, "origins"))
+    async def browser_local_storage_set(self, origins: list[dict], context: Optional[str] = None) -> dict:
+        await self.control.set_local_storage(_parsed(OriginStorage, origins, "origins"), self.contexts.id_of(context))
         return {}
 
     @extension(BROWSER, op="local_storage/clear")
-    async def browser_local_storage_clear(self, origins: Optional[list[str]] = None) -> dict:
-        return {"origins": await self.control.clear_local_storage(origins)}
+    async def browser_local_storage_clear(self, origins: Optional[list[str]] = None,
+                                          context: Optional[str] = None) -> dict:
+        return {"origins": await self.control.clear_local_storage(origins, self.contexts.id_of(context))}
 
     @extension(BROWSER, op="downloads/list", method="GET")
-    async def browser_downloads_list(self) -> dict:
-        return {"downloads": self.control.download_list()}
+    async def browser_downloads_list(self, context: Optional[str] = None) -> dict:
+        return {"downloads": self.control.download_list(self.contexts.id_of(context))}
 
     @extension(BROWSER, op="downloads/get")
-    async def browser_downloads_get(self, guid: str, write_namespace: Optional[dict] = None) -> dict:
-        """The download ``guid`` and, completed, its file: uploaded under ``write_namespace``, a grant, when given,
-        else inline."""
-        download, grant = self.control.download(guid), _grant(write_namespace)
+    async def browser_downloads_get(self, guid: str, write_namespace: Optional[dict] = None,
+                                    context: Optional[str] = None) -> dict:
+        """The download ``guid`` of the context ``context``, else of the default one, and, completed, its file:
+        uploaded under ``write_namespace``, a grant, when given, else inline."""
+        download, grant = self.control.download(guid, self.contexts.id_of(context)), _grant(write_namespace)
         home = Path.home().resolve()
         landed = Path(download["path"]).resolve() if download["state"] == "completed" and download["path"] else None
         parts = await file_parts(home, [landed.relative_to(home).as_posix()], grant) \
@@ -585,14 +629,15 @@ def declared_extensions(self) -> list[EnvironmentExtension]:
                                       IntakeFormat(part="data", format="json", load="replace")])
         return [*super().declared_extensions(), intake_extension(tree, (
             f"data/get returns the browser's state as {data.STATE_FILE}: its cookies and local storage as Playwright's "
-            f"storageState has them, its tabs open and closed, its downloads and its clock; beside it, its log as "
-            f"{data.LOG_FILE} and, when a proxy logs for it and its network setting is on, its network log as HAR "
-            f"1.2 in {HAR_FILE}, an "
-            f"entry for each request and tunnel in the order they started, both of which data/add passes over, its "
-            f"profile "
-            f"without caches, and its finished downloads. data/add applies such a state, while the browser runs, and "
-            f"writes files by their path: its profile, restored with the browser stopped, ~/{DOWNLOADS} and "
-            f"~/{UPLOADS}. data/reset puts the profile back as installed and relaunches it at its start tabs."))]
+            f"storageState has them, its tabs open and closed, its downloads, its clock and, under contexts, each "
+            f"lease's by its label; beside it, its log as {data.LOG_FILE} and, when a proxy logs for it and its "
+            f"network setting is on, its network log as HAR 1.2 in {HAR_FILE}, an entry for each request and tunnel "
+            f"in the order they started, both of which data/add passes over, its profile without caches, and its "
+            f"finished downloads, a lease's under ~/{CONTEXTS}/<label>/{DOWNLOADS}. data/add applies such a state, "
+            f"while the browser runs, leasing each context it names that isn't leased, and writes files by their "
+            f"path: its profile, restored with the browser stopped, ~/{DOWNLOADS}, ~/{UPLOADS} and a lease's "
+            f"downloads. data/reset ends every lease, puts the profile back as installed and relaunches it at its "
+            f"start tabs."))]
 
     @get_data
     async def browser_get_data(self, write_namespace: Optional[WriteNamespaceGrant] = None) -> list:
@@ -601,12 +646,22 @@ async def browser_get_data(self, write_namespace: Optional[WriteNamespaceGrant]
         with the browser paused so its files are of one moment, and its finished downloads: each a file uploaded under
         ``write_namespace`` when there is one, else inline."""
         home = Path.home()
+        await self.contexts.find_unseen()
+        leases = list(self.contexts)
         state = BrowserState(cookies=await self.control.cookies(), local_storage=await self.control.local_storage(),
                              tabs=await self.control.tab_list(),
-                             closed_tabs=(record := await self.control.record())["closed_tabs"],
-                             downloads=record["downloads"], clock={"mode": "real", "now": _now()},
-                             start_tabs=self.start_tab_launches[-1]["tabs"] if self.start_tab_launches else [])
-        written = {**state.model_dump(), "cookies": [cookie.model_dump(exclude_none=True) for cookie in state.cookies]}
+                             closed_tabs=(await self.control.record())["closed_tabs"],
+                             downloads=self.control.download_list(), clock={"mode": "real", "now": _now()},
+                             start_tabs=self.start_tab_launches[-1]["tabs"] if self.start_tab_launches else [],
+                             contexts={lease.label: ContextState(
+                                 made_by=lease.made_by, grants=lease.grants,
+                                 cookies=await self.control.cookies(context=lease.id),
+                                 local_storage=await self.control.local_storage(context=lease.id),
+                                 tabs=await self.control.tab_list(lease.id),
+                                 downloads=self.control.download_list(lease.id)) for lease in leases})
+        written = {**state.model_dump(), "cookies": _written(state.cookies),
+                   "contexts": {label: {**context.model_dump(), "cookies": _written(context.cookies)}
+                                for label, context in state.contexts.items()}}
         (home / ".cache").mkdir(exist_ok=True)
         with tempfile.TemporaryDirectory(dir=home / ".cache") as staging:
             root = Path(staging)
@@ -619,7 +674,9 @@ async def browser_get_data(self, write_namespace: Optional[WriteNamespaceGrant]
             with self._computer_app.paused():
                 await app_data.in_thread(data.stage_profile, home, self.profile, root)
             parts = await file_parts(root, [*exported, self.profile], write_namespace)
-        return parts + await file_parts(home, data.finished_downloads(home), write_namespace)
+        downloads = [*data.finished_downloads(home),
+                     *(path for lease in leases for path in data.finished_downloads(home, lease.under()))]
+        return parts + await file_parts(home, downloads, write_namespace)
 
     @add_data
     async def browser_add_data(self, parts: list) -> None:
@@ -634,10 +691,12 @@ async def browser_add_data(self, parts: list) -> None:
             raise InvalidArgument(f"{data.STATE_FILE}: " + "; ".join(
                 f"{'.'.join(map(str, error['loc'])) or 'it'}: {error['msg']}"
                 for error in e.errors(include_input=False, include_url=False)))
-        if agent_acted() and (load.profile or state.tabs is not None):
+        if agent_acted() and (load.profile or state.tabs is not None or
+                              any(context.tabs is not None for context in state.contexts.values())):
             raise InvalidArgument("an agent has acted in this computer, so a load can't change the browser's "
                                   "profile or tabs, which would end what it's doing; only its cookies, local storage "
                                   "and files")
+        _check_contexts(state, load, set() if load.profile else {lease.label for lease in self.contexts})
         applied: list[str] = []
         try:
             if load.profile:
@@ -662,16 +721,37 @@ async def browser_add_data(self, parts: list) -> None:
             elif (state.cookies or state.local_storage) and not agent_acted():
                 _refuse_failed(await self._load_start_tabs(self.settings.start_urls, _now()))
                 applied.append("the start tabs again")
+            for label in [*state.contexts, *(label for label in load.context_files if label not in state.contexts)]:
+                await self._load_context(label, state.contexts.get(label), load.context_files.get(label, {}))
+                applied.append(f"the context {label!r}")
         except Exception as e:
             done = ", ".join(applied) or "nothing"
             raise type(e)(f"{e} (the load had applied {done})") if isinstance(e, (ValueError, InvalidArgument)) \
                 else RuntimeError(f"{type(e).__name__}: {e} (the load had applied {done})") from e
 
+    async def _load_context(self, label: str, loaded: Optional[ContextToLoad], files: dict[str, bytes]) -> None:
+        """The lease ``label``, leased as ``loaded`` says when it isn't, its downloads ``files`` written, then its
+        cookies, local storage and tabs loaded."""
+        lease = self.contexts.get(label) if loaded is None else \
+            await self.contexts.lease(label, made_by=loaded.made_by, grants=tuple(loaded.grants))
+        if files:
+            await app_data.in_thread(app_data.write_within, Path.home(), files, [lease.under()])
+        if loaded is None:
+            return
+        if loaded.cookies:
+            await self.control.set_cookies(loaded.cookies, lease.id)
+        if loaded.local_storage:
+            await self.control.set_local_storage(loaded.local_storage, lease.id)
+        if loaded.tabs is not None:
+            await self.control.replace_tabs(loaded.tabs, lease.id)
+
     @reset_data
     async def browser_reset_data(self) -> None:
-        """With the browser stopped: its addresses ended, its profile as installed, its downloads and uploads gone and
-        a record that starts now. Its data plane launches it again after, at its start tabs."""
+        """With the browser stopped: its addresses ended, every lease with it, its profile as installed, its
+        downloads and uploads gone and a record that starts now. Its data plane launches it again after, at its start
+        tabs."""
         self.relay.ended()
+        self.contexts.ended()
         self.cdp_tokens.revoke_all()
         self.log.note("reset", {})
         await app_data.reset(self.paths)
@@ -872,6 +952,22 @@ def _origin(value: Any) -> str:
     return f"{parts.scheme}://{parts.netloc}{parts.path}"
 
 
+def _written(cookies: list) -> list[dict]:
+    """``cookies`` as a snapshot keeps them, without the fields the browser left unset."""
+    return [cookie.model_dump(exclude_none=True) for cookie in cookies]
+
+
+def _check_contexts(state: StateToLoad, load: data.Load, leased: set[str]) -> None:
+    """InvalidArgument, before a load applies anything, for a context it would lease by a label no lease can have, or
+    downloads it writes for a context it neither leases nor finds leased: ``leased``, none once a profile it restores
+    relaunches the browser."""
+    for label, context in state.contexts.items():
+        if label not in leased and (problem := label_problem(label, by_task=context.made_by == TASK)):
+            raise InvalidArgument(f"{data.STATE_FILE}: contexts: {problem}")
+    if orphans := sorted(set(load.context_files) - set(state.contexts) - leased):
+        raise InvalidArgument(f"the load writes downloads for contexts it doesn't lease and that aren't leased: "
+                              f"{', '.join(orphans)}")
+
 def _parsed(model: type[BaseModel], items: Any, what: str) -> list:
     """Each of ``items`` as ``model``; InvalidArgument naming the fields that don't fit and never their values, which
     for a cookie are its credentials."""
diff --git a/packages/agentenv-protocol/src/agentenv_protocol/website_browser/log.py b/packages/agentenv-protocol/src/agentenv_protocol/website_browser/log.py
index 1a25df719..ad384060d 100644
--- a/packages/agentenv-protocol/src/agentenv_protocol/website_browser/log.py
+++ b/packages/agentenv-protocol/src/agentenv_protocol/website_browser/log.py
@@ -74,7 +74,7 @@
 #: The ``browser/v1`` ops that act; any other reads.
 ACTING_OPS = frozenset({"page/input", "navigate", "history", "tabs/open", "tabs/activate", "tabs/close",
                         "dialog/answer", "files/choose", "cookies/set", "cookies/delete", "local_storage/set",
-                        "local_storage/clear", "sites/set"})
+                        "local_storage/clear", "sites/set", "contexts/lease", "contexts/grant", "contexts/release"})
 #: The ``browser/v1`` ops an agent's calls are never logged for: the logs themselves, and agentenv's own bookkeeping,
 #: a driver's calls that begin and end a tool call's own entry among them.
 UNLOGGED_OPS = frozenset({"log", "network", "record", "calls/begin", "calls/end"})
diff --git a/packages/agentenv-protocol/src/agentenv_protocol/website_browser/shapes.py b/packages/agentenv-protocol/src/agentenv_protocol/website_browser/shapes.py
index 33443ec13..f3b8e9f00 100644
--- a/packages/agentenv-protocol/src/agentenv_protocol/website_browser/shapes.py
+++ b/packages/agentenv-protocol/src/agentenv_protocol/website_browser/shapes.py
@@ -75,13 +75,15 @@ def _an_origin(cls, origin: str) -> str:
 
 
 class OpenTab(BaseModel):
-    """An open tab, by the browser's target id, with the tab that opened it, a popup's, and whether it's active."""
+    """An open tab, by the browser's target id, with the tab that opened it, a popup's, whether it's its context's
+    active tab, and the label of the lease it's in, None for the default context."""
     id: str
     url: str
     title: str
     opened_at: str
     opener: Optional[str] = None
     active: bool
+    context: Optional[str] = None
 
 
 class ClosedTab(BaseModel):
@@ -94,10 +96,12 @@ class ClosedTab(BaseModel):
     opener: Optional[str] = None
     closed_at: str
     closed_by: Literal["agentenv", "unknown", "exit", "stop"]
+    context: Optional[str] = None
 
 
 class Download(BaseModel):
-    """A download into ``~/Downloads``; when completed, with where it landed, and its size and sha256 when available."""
+    """A download into ``~/Downloads``, or a lease's into its own folder, by the lease's label; when completed, with
+    where it landed, and its size and sha256 when available."""
     guid: str
     url: str
     filename: str
@@ -107,6 +111,7 @@ class Download(BaseModel):
     path: Optional[str] = None
     size: Optional[int] = None
     sha256: Optional[str] = None
+    context: Optional[str] = None
 
 
 class Dialog(BaseModel):
@@ -142,14 +147,28 @@ class TabToOpen(BaseModel):
     active: bool = False
 
 
+class ContextToLoad(BaseModel):
+    """A lease ``data/add`` makes when it isn't leased, who made it and its grants, and the cookies, local storage and,
+    when given, tabs it loads into it. A snapshot's context is one."""
+    model_config = ConfigDict(extra="ignore")
+
+    made_by: str = Field("task", min_length=1)
+    grants: list[str] = []
+    cookies: list[CookieToSet] = []
+    local_storage: list[OriginStorage] = []
+    tabs: Optional[list[TabToOpen]] = None
+
+
 class StateToLoad(BaseModel):
-    """What ``data/add`` applies of the browser's state: its cookies, its local storage and, when given, its tabs.
-    A snapshot's state loads as it is: what it records of the past, its closed tabs, downloads and clock, is left."""
+    """What ``data/add`` applies of the browser's state: its cookies, its local storage and, when given, its tabs,
+    and its leases by label. A snapshot's state loads as it is: what it records of the past, its closed tabs,
+    downloads and clock, is left."""
     model_config = ConfigDict(extra="ignore")
 
     cookies: list[CookieToSet] = []
     local_storage: list[OriginStorage] = []
     tabs: Optional[list[TabToOpen]] = None
+    contexts: dict[str, ContextToLoad] = {}
 
 
 class SiteNames(BaseModel):
@@ -187,8 +206,20 @@ class Clock(BaseModel):
     now: str
 
 
+class ContextState(BaseModel):
+    """A lease's state in ``data/get``: who made it, the agents it's granted to, and its cookies, local storage, open
+    tabs and downloads."""
+    made_by: str
+    grants: list[str]
+    cookies: list[Cookie]
+    local_storage: list[OriginStorage]
+    tabs: list[OpenTab]
+    downloads: list[Download]
+
+
 class BrowserState(BaseModel):
-    """``data/get``'s state of the browser, read at one moment and kept as ``browser-state.json`` in a snapshot."""
+    """``data/get``'s state of the browser, read at one moment and kept as ``browser-state.json`` in a snapshot: its
+    default context's cookies, local storage, tabs and downloads, every tab it closed, and each lease's by label."""
     cookies: list[Cookie]
     local_storage: list[OriginStorage]
     tabs: list[OpenTab]
@@ -197,6 +228,7 @@ class BrowserState(BaseModel):
     clock: Clock
     #: The start tabs of its latest launch.
     start_tabs: list[StartTab] = []
+    contexts: dict[str, ContextState] = {}
 
 
 class BrowserRecord(BaseModel):
diff --git a/packages/agentenv-protocol/tests/test_browser_cdp.py b/packages/agentenv-protocol/tests/test_browser_cdp.py
index ff6c0233b..d9440a81a 100644
--- a/packages/agentenv-protocol/tests/test_browser_cdp.py
+++ b/packages/agentenv-protocol/tests/test_browser_cdp.py
@@ -24,6 +24,8 @@
 from agentenv_protocol.website_browser import cdp as browser_cdp  # noqa: E402
 from agentenv_protocol.website_browser import log as browser_log  # noqa: E402
 from agentenv_protocol.website_browser.cdp import NO_SESSION, Relay, Tokens, guard  # noqa: E402
+from agentenv_protocol.website_browser.contexts import Contexts  # noqa: E402
+from agentenv_protocol.website_browser.control import BrowserControl  # noqa: E402
 from agentenv_protocol.website_browser.log import REDACTED, TOOL_CALL_HEADER, BrowserLog, Causes, tool_call_header  # noqa: E402
 from agentenv_protocol.computer import Launch, Platform, Ready, app, computer_app, linux  # noqa: E402
 from agentenv_protocol.computer.app import APP_SETTINGS_ENV  # noqa: E402
@@ -90,6 +92,26 @@ async def request(self, method, params=None, *, session_id=None, answered=None):
         return {"result": {"method": method, "session": session_id}}
 
 
+class ContextPipe(Pipe):
+    """A browser's pipe that makes a context ``TASK`` for agentenv's own connection and ``A<n>`` for an agent's."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.made = 0
+
+    async def call(self, method, params=None, *, session_id=None, timeout_s=None):
+        if method == "Target.createBrowserContext":
+            return {"browserContextId": "TASK"}
+        return await super().call(method, params, session_id=session_id, timeout_s=timeout_s)
+
+    async def request(self, method, params=None, *, session_id=None, answered=None):
+        if method == "Target.createBrowserContext":
+            self.sent.append((method, session_id))
+            self.made += 1
+            return {"result": {"browserContextId": f"A{self.made}"}}
+        return await super().request(method, params, session_id=session_id, answered=answered)
+
+
 class SlowClient:
     """A client's WebSocket that takes in nothing sent to it until ``reading`` is set, and records what it got and how
     it was closed."""
@@ -114,10 +136,10 @@ async def close(self, code: int = 1000, reason: str = "") -> None:
 
 
 @contextlib.asynccontextmanager
-async def _relay(dialogs_answered: bool = False, **logging):
-    """The relay over a fake pipe, served on loopback with each connection's user its path's: the pipe, the relay and
-    the server's ws:// base."""
-    pipe = Pipe()
+async def _relay(dialogs_answered: bool = False, pipe=None, **logging):
+    """The relay over a fake pipe, ``pipe`` when given, served on loopback with each connection's user its path's: the
+    pipe, the relay and the server's ws:// base."""
+    pipe = pipe or Pipe()
     relay = Relay(pipe, dialogs_answered=dialogs_answered, **logging)
 
     async def endpoint(websocket):
@@ -280,6 +302,41 @@ async def test_the_guard_keeps_the_browser_up_its_traffic_and_downloads_its_own_
         ("Browser.close", "closed")]
 
 
+@pytest.mark.asyncio
+async def test_a_context_an_agent_makes_is_its_lease_keeping_downloads_in_its_folder_and_only_it_may_end_it(tmp_path):
+    pipe = ContextPipe()
+    contexts = Contexts(pipe, BrowserControl(pipe, "agent"), home=lambda: tmp_path)
+    task = await contexts.lease("buyer")
+    async with _relay(pipe=pipe, contexts=contexts) as (_, relay, base):
+        async with connect(f"{base}/ada") as ada, connect(f"{base}/bob") as bob:
+            made = await _ask(ada, {"id": 1, "method": "Target.createBrowserContext", "params": {}})
+            await _ask(ada, {"id": 2, "method": "Browser.setDownloadBehavior", "params": {
+                "behavior": "allowAndName", "browserContextId": "A1", "downloadPath": "/tmp/elsewhere",
+                "eventsEnabled": True}})
+            downloads = pipe.params["Browser.setDownloadBehavior"]
+            theirs = await _ask(bob, {"id": 1, "method": "Target.disposeBrowserContext",
+                                      "params": {"browserContextId": "A1"}})
+            tasks = await _ask(ada, {"id": 3, "method": "Target.disposeBrowserContext",
+                                     "params": {"browserContextId": task.id}})
+            ended = await _ask(ada, {"id": 4, "method": "Target.disposeBrowserContext",
+                                     "params": {"browserContextId": "A1"}})
+            await _ask(bob, {"id": 2, "method": "Target.createBrowserContext", "params": {"disposeOnDetach": True}})
+            while_bob = [lease.label for lease in contexts]
+        for _ in range(500):
+            if contexts.get("agent-bob-1") is None:
+                break
+            await asyncio.sleep(0.01)
+
+    assert made == {"id": 1, "result": {"browserContextId": "A1"}}
+    assert downloads == {"behavior": "allow", "downloadPath": str(tmp_path / "Contexts" / "agent-ada-1" / "Downloads"),
+                         "browserContextId": "A1", "eventsEnabled": True}
+    assert theirs["error"]["message"] == ("agentenv refuses Target.disposeBrowserContext: the context 'agent-ada-1' "
+                                          "is another agent's")
+    assert "the context 'buyer' is the task's" in tasks["error"]["message"] and "result" in ended
+    assert while_bob == ["buyer", "agent-bob-1"] and [lease.label for lease in contexts] == ["buyer"]
+    assert [entry["did"] for entry in relay.connections[0]["guarded"]] == ["changed", "refused"]
+
+
 @pytest.mark.asyncio
 async def test_a_client_that_falls_too_far_behind_is_closed_and_what_waited_for_it_dropped(monkeypatch):
     monkeypatch.setattr(browser_cdp, "OUTBOX_LIMIT_BYTES", 10_000)
@@ -479,7 +536,7 @@ async def test_an_op_for_an_agents_tool_call_and_agentenvs_own_acting_ops_are_en
     async def navigate(url):
         browser.control._acted_on("T1")
 
-    async def tabs():
+    async def tabs(context=None):
         return []
 
     monkeypatch.setattr(browser.control, "navigate", navigate)
@@ -675,7 +732,7 @@ async def call(method, params=None, *, session_id=None, timeout_s=None):
     async def gone(method, params=None, *, session_id=None, timeout_s=None):
         raise ConnectionError("the browser closed its debugging pipe")
 
-    async def tabs():
+    async def tabs(context=None):
         return [{"id": "T1", "url": "https://site.test/", "title": "Site", "active": True}]
 
     monkeypatch.setattr(browser, "_until_ready", ready)
diff --git a/packages/agentenv-protocol/tests/test_browser_contexts.py b/packages/agentenv-protocol/tests/test_browser_contexts.py
new file mode 100644
index 000000000..722f534a4
--- /dev/null
+++ b/packages/agentenv-protocol/tests/test_browser_contexts.py
@@ -0,0 +1,281 @@
+"""browser/v1's contexts: a lease by its label, the same one when leased again, its downloads in its own folder; labels
+a task can and can't use; a context an agent makes leased to it as agent-<user>-<n>, and one made unseen to nobody;
+each context's tabs, cookies, local storage and downloads its own; a release that closes its tabs as agentenv's and
+deletes its folder; and what a load may name."""
+from __future__ import annotations
+
+import asyncio
+from pathlib import PurePosixPath
+
+import pytest
+
+from agentenv_protocol import website_browser
+from agentenv_protocol.computer import Launch, Ready, app, linux
+from agentenv_protocol.computer.errors import InvalidArgument, TargetUnavailable
+from agentenv_protocol.computer.platform import Platform
+from agentenv_protocol.website_browser import BrowserControl, CookieToSet, WebsiteBrowserEnvironment, data
+from agentenv_protocol.website_browser.contexts import Contexts, label_problem
+from agentenv_protocol.website_browser.environment import _check_contexts
+from agentenv_protocol.website_browser.shapes import StateToLoad
+
+
+@linux(launch=Launch(command=["chromium/chrome"], window={"class": "Chromium"}, ready=Ready(window=True)))
+class Browser(WebsiteBrowserEnvironment):
+    version = "156.0.8078.4"
+
+
+@pytest.fixture(autouse=True)
+def browser_home(monkeypatch, tmp_path):
+    monkeypatch.setattr(app, "detect", lambda: Platform(os="linux"))
+    monkeypatch.setattr(website_browser.environment, "_shm_bytes", lambda path="/dev/shm": 1 << 30)
+    monkeypatch.setenv("HOME", str(tmp_path / "home"))
+    (tmp_path / "home").mkdir()
+    monkeypatch.setenv("ENVIRONMENT_NAME", "chromium")
+    return tmp_path / "home"
+
+
+class StubDevTools:
+    """A browser connection that makes a context ``C<n>`` for each one asked for, answers each other call from
+    ``answers`` by method, records every call, and hands the control the events a test sends."""
+
+    def __init__(self, answers=None):
+        self.calls, self.answers, self.listeners, self.made = [], answers or {}, [], 0
+
+    def listen(self, listener):
+        self.listeners.append(listener)
+
+    async def call(self, method, params=None, *, session_id=None, timeout_s=None):
+        self.calls.append((method, params or {}, session_id))
+        if method == "Target.createBrowserContext":
+            self.made += 1
+            return {"browserContextId": f"C{self.made}"}
+        answer = self.answers.get(method, {})
+        return answer(params, session_id) if callable(answer) else answer
+
+    def send(self, method, params, session=None):
+        for listener in self.listeners:
+            listener({"method": method, "params": params, **({"sessionId": session} if session else {})})
+
+
+def _sent(devtools, method):
+    return [params for called, params, _ in devtools.calls if called == method]
+
+
+def _contexts(home, answers=None):
+    devtools = StubDevTools(answers)
+    control = BrowserControl(devtools, "agent")
+    contexts = Contexts(devtools, control, home=lambda: home)
+    control.download_folders = contexts.holding
+    return devtools, control, contexts
+
+
+def _tab(devtools, target, context, url="https://shop.test/"):
+    devtools.send("Target.targetCreated", {"targetInfo": {"targetId": target, "type": "page", "url": url,
+                                                          "title": target, "browserContextId": context}})
+
+
+@pytest.mark.asyncio
+async def test_a_lease_is_a_context_of_its_own_by_its_label_saving_downloads_in_its_folder_and_found_again(
+        browser_home):
+    devtools, control, contexts = _contexts(browser_home)
+
+    lease = await contexts.lease("buyer")
+    again = await contexts.lease("buyer")
+
+    assert (lease.label, lease.id, lease.made_by, lease.grants) == ("buyer", "C1", "task", [])
+    assert again is lease and _sent(devtools, "Target.createBrowserContext") == [{"disposeOnDetach": False}]
+    assert _sent(devtools, "Browser.setDownloadBehavior") == [{
+        "behavior": "allow", "browserContextId": "C1", "eventsEnabled": True,
+        "downloadPath": str(browser_home / "Contexts" / "buyer" / "Downloads")}]
+    assert (browser_home / "Contexts" / "buyer" / "Downloads").is_dir()
+    assert control.other_contexts == {"C1": "buyer"}
+    assert contexts.id_of("buyer") == "C1" and contexts.id_of(None) is None
+    with pytest.raises(TargetUnavailable, match="no context 'seller' is leased"):
+        contexts.id_of("seller")
+
+
+@pytest.mark.parametrize("label, by_task, problem", [
+    ("buyer-2", True, None), ("b", True, None), ("x" * 40, True, None), ("agent-ada-1", False, None),
+    ("Buyer", True, "lowercase"), ("-buyer", True, "lowercase"), ("buyer-", True, "lowercase"),
+    ("buy_er", True, "lowercase"), ("", True, "lowercase"), ("x" * 41, True, "lowercase"), (None, True, "lowercase"),
+    ("agent-ada-1", True, "names a context an agent made"),
+])
+def test_a_label_is_lowercase_letters_digits_and_dashes_and_a_tasks_never_starts_agent(label, by_task, problem):
+    found = label_problem(label, by_task=by_task)
+    assert found is None if problem is None else problem in found
+
+
+@pytest.mark.asyncio
+async def test_a_task_cant_lease_an_agents_label_and_grants_are_recorded_once_each(browser_home):
+    _, _, contexts = _contexts(browser_home)
+    with pytest.raises(InvalidArgument, match="names a context an agent made"):
+        await contexts.lease("agent-ada-1")
+    await contexts.lease("buyer", grants=("ada",))
+
+    contexts.grant("buyer", "bob")
+    contexts.grant("buyer", "ada")
+
+    assert contexts.get("buyer").record() == {"context": "buyer", "id": "C1", "made_by": "task",
+                                              "grants": ["ada", "bob"]}
+    with pytest.raises(TargetUnavailable):
+        contexts.grant("seller", "ada")
+    with pytest.raises(InvalidArgument, match="non-empty"):
+        contexts.grant("buyer", "")
+
+
+@pytest.mark.asyncio
+async def test_a_context_an_agent_makes_is_leased_to_it_and_one_made_unseen_to_nobody(browser_home):
+    devtools, control, contexts = _contexts(browser_home, {
+        "Target.getBrowserContexts": {"browserContextIds": ["X1", "X2", "X9"]}})
+
+    first, second = contexts.made_by_agent("ada", "X1"), contexts.made_by_agent("ada", "X2")
+    named = contexts.made_by_agent("Ada Lovelace!", "X3")
+    long = contexts.made_by_agent("a-very-long-user-name-that-will-not-fit-in-a-label", "X4")
+    [unseen] = await contexts.find_unseen()
+
+    assert [first.label, second.label, named.label] == ["agent-ada-1", "agent-ada-2", "agent-ada-lovelace-1"]
+    assert (first.made_by, first.grants) == ("ada", ["ada"]) and contexts.made_by_agent("ada", "X1") is first
+    assert len(long.label) <= 40 and long.label.startswith("agent-a-very-long") and long.label.endswith("-1")
+    assert (unseen.label, unseen.id, unseen.made_by, unseen.grants) == ("agent-unknown-1", "X9", "unknown", [])
+    assert set(control.other_contexts) == {"X1", "X2", "X3", "X4", "X9"}
+
+
+@pytest.mark.asyncio
+async def test_only_the_agent_that_made_a_context_may_dispose_it(browser_home):
+    _, _, contexts = _contexts(browser_home)
+    await contexts.lease("buyer")
+    contexts.made_by_agent("ada", "X1")
+
+    assert contexts.may_dispose("ada", "X1") is None and contexts.may_dispose("ada", "elsewhere") is None
+    assert "another agent's" in contexts.may_dispose("bob", "X1")
+    assert "the task's" in contexts.may_dispose("ada", "C1")
+    contexts.disposed("X1")
+    assert contexts.get("agent-ada-1") is None
+
+
+@pytest.mark.asyncio
+async def test_each_contexts_tabs_cookies_and_local_storage_are_its_own(browser_home):
+    devtools, control, contexts = _contexts(browser_home, {"Storage.getCookies": {"cookies": []}})
+    await contexts.lease("buyer")
+    _tab(devtools, "D1", "DEFAULT")
+    _tab(devtools, "L1", "C1", "https://cart.test/")
+
+    default, leased = await control.tab_list(), await control.tab_list("C1")
+    every = await control.tab_list(every=True)
+    await control.cookies(context="C1")
+    await control.set_cookies([CookieToSet(name="sid", value="v", domain="cart.test")], "C1")
+
+    assert [(tab["id"], tab["context"]) for tab in default] == [("D1", None)]
+    assert [(tab["id"], tab["context"]) for tab in leased] == [("L1", "buyer")]
+    assert [tab["id"] for tab in every] == ["D1", "L1"]
+    assert _sent(devtools, "Storage.getCookies") == [{"browserContextId": "C1"}]
+    assert _sent(devtools, "Storage.setCookies")[0]["browserContextId"] == "C1"
+    assert control.origins == {"https://shop.test"} and control.origins_of("C1") == {"https://cart.test"}
+    with pytest.raises(InvalidArgument, match="no tab D1 is open in that context"):
+        await control.activate("D1", "C1")
+    with pytest.raises(InvalidArgument, match="no tab L1 is open; list the tabs"):
+        await control.close("L1")
+
+
+@pytest.mark.asyncio
+async def test_a_leases_downloads_are_its_own_by_the_tab_that_began_them_or_the_folder_they_land_in(browser_home):
+    devtools, control, contexts = _contexts(browser_home)
+    lease = await contexts.lease("buyer")
+    _tab(devtools, "L1", "C1")
+    landed = lease.downloads(browser_home) / "invoice.pdf"
+    landed.write_bytes(b"%PDF")
+
+    devtools.send("Browser.downloadWillBegin", {"guid": "g1", "url": "https://shop.test/i", "frameId": "L1",
+                                                "suggestedFilename": "invoice.pdf"})
+    devtools.send("Browser.downloadWillBegin", {"guid": "g2", "url": "https://shop.test/j", "frameId": "iframe",
+                                                "suggestedFilename": "invoice.pdf"})
+    devtools.send("Browser.downloadProgress", {"guid": "g2", "state": "completed", "filePath": str(landed)})
+
+    assert control.download_list() == []
+    assert [(d["guid"], d["context"]) for d in control.download_list("C1")] == [("g1", "buyer"), ("g2", "buyer")]
+    assert control.download("g1", "C1")["context"] == "buyer"
+    with pytest.raises(InvalidArgument, match="no download g1 has begun; list the downloads"):
+        control.download("g1")
+    assert data.finished_downloads(browser_home, lease.under()) == ["Contexts/buyer/Downloads/invoice.pdf"]
+
+
+@pytest.mark.asyncio
+async def test_a_release_closes_its_tabs_as_agentenvs_deletes_its_folder_and_does_nothing_again(browser_home):
+    devtools, control, contexts = _contexts(browser_home)
+    lease = await contexts.lease("buyer")
+    _tab(devtools, "L1", "C1")
+
+    assert await contexts.release("buyer") is True
+    devtools.send("Target.targetDestroyed", {"targetId": "L1"})
+
+    assert _sent(devtools, "Target.disposeBrowserContext") == [{"browserContextId": "C1"}]
+    assert not lease.folder(browser_home).exists() and contexts.get("buyer") is None
+    assert [(tab["id"], tab["closed_by"]) for tab in (await control.record())["closed_tabs"]] == [("L1", "agentenv")]
+    assert (await control.record())["closed_tabs"][0]["context"] == "buyer"
+    assert await contexts.release("buyer") is False
+    assert await control.tab_list() == []
+
+
+@pytest.mark.asyncio
+async def test_a_label_released_and_leased_again_at_once_keeps_the_new_leases_folder(browser_home):
+    _, _, contexts = _contexts(browser_home)
+    await contexts.lease("buyer")
+
+    released, again = await asyncio.gather(contexts.release("buyer"), contexts.lease("buyer"))
+
+    assert released is True and again.id == "C2" and again.downloads(browser_home).is_dir()
+
+
+@pytest.mark.asyncio
+async def test_the_browser_ending_ends_every_lease_and_deletes_their_folders(browser_home):
+    _, _, contexts = _contexts(browser_home)
+    await contexts.lease("buyer")
+    contexts.made_by_agent("ada", "X1")
+
+    contexts.ended()
+
+    assert list(contexts) == [] and not (browser_home / "Contexts").exists()
+    assert (await contexts.lease("buyer")).id == "C2"
+
+
+def test_a_load_refuses_a_label_no_lease_can_have_and_downloads_for_a_context_it_doesnt_lease():
+    state = StateToLoad.model_validate({"contexts": {"buyer": {}, "agent-ada-1": {"made_by": "ada"}}})
+    files = data.Load(context_files={"buyer": {}, "seller": {}})
+
+    _check_contexts(state, data.Load(context_files={"buyer": {}}), set())
+    _check_contexts(state, files, {"seller"})
+    with pytest.raises(InvalidArgument, match="seller"):
+        _check_contexts(state, files, set())
+    with pytest.raises(InvalidArgument, match="names a context an agent made"):
+        _check_contexts(StateToLoad.model_validate({"contexts": {"agent-ada-1": {}}}), data.Load(), set())
+
+
+def test_a_loads_files_under_a_leases_downloads_are_its_and_any_other_under_contexts_none():
+    assert data.context_of(PurePosixPath("Contexts/buyer/Downloads/a.pdf")) == "buyer"
+    assert data.context_of(PurePosixPath("Contexts/buyer/Downloads/sub/a.pdf")) == "buyer"
+    assert data.context_of(PurePosixPath("Contexts/buyer/Downloads")) is None
+    assert data.context_of(PurePosixPath("Contexts/buyer/profile/a")) is None
+    assert data.context_of(PurePosixPath("Downloads/a.pdf")) is None
+
+
+@pytest.mark.asyncio
+async def test_the_ops_lease_grant_list_and_release_and_name_a_context_by_its_label(browser_home, monkeypatch):
+    browser = Browser()
+    devtools = StubDevTools({"Storage.getCookies": {"cookies": []},
+                             "Target.getBrowserContexts": {"browserContextIds": ["C1"]}})
+    devtools.listen(browser.control._event)
+    browser.devtools = browser.contexts.devtools = browser.control.devtools = devtools
+    monkeypatch.setattr(browser.contexts, "home", lambda: browser_home)
+
+    leased = await browser.browser_contexts_lease("buyer")
+    await browser.browser_contexts_grant("buyer", "ada")
+    _tab(devtools, "L1", "C1")
+    listed = await browser.browser_contexts_list()
+    tabs = await browser.browser_tabs_list(context="buyer")
+
+    assert leased == {"context": "buyer", "id": "C1"}
+    assert listed == {"contexts": [{"context": "buyer", "id": "C1", "made_by": "task", "grants": ["ada"]}]}
+    assert [tab["id"] for tab in tabs["tabs"]] == ["L1"] and (await browser.browser_tabs_list())["tabs"] == []
+    with pytest.raises(TargetUnavailable):
+        await browser.browser_cookies_get(context="seller")
+    assert await browser.browser_contexts_release("seller") == {"released": False}
diff --git a/packages/agentenv-protocol/tests/test_browser_data.py b/packages/agentenv-protocol/tests/test_browser_data.py
index 08b92c53e..709b7e0b3 100644
--- a/packages/agentenv-protocol/tests/test_browser_data.py
+++ b/packages/agentenv-protocol/tests/test_browser_data.py
@@ -41,13 +41,13 @@ def __init__(self):
         self.cookie_list = [{"name": "sid", "value": "s1", "domain": "shop.test", "path": "/", "expires": -1,
                              "httpOnly": True, "secure": False, "sameSite": "Lax"}]
 
-    async def cookies(self, urls=None):
+    async def cookies(self, urls=None, context=None):
         return self.cookie_list
 
-    async def local_storage(self, origins=None):
+    async def local_storage(self, origins=None, context=None):
         return [{"origin": "https://shop.test", "localStorage": [{"name": "cart", "value": "3"}]}]
 
-    async def tab_list(self):
+    async def tab_list(self, context=None, *, every=False):
         return [{"id": "t1", "url": "https://shop.test/", "title": "Shop", "opened_at": "t0", "opener": None,
                  "active": True}]
 
@@ -55,18 +55,21 @@ async def record(self):
         return {"closed_tabs": [{"id": "t0", "url": "about:blank", "title": "", "opened_at": "t0", "opener": None,
                                  "closed_at": "t1", "closed_by": "agentenv"}], "downloads": []}
 
+    def download_list(self, context=None, *, every=False):
+        return []
+
     async def _done(self, what, value=None):
         if self.fail == what:
             raise RuntimeError(f"{what} failed")
         self.did.append((what, value))
 
-    async def set_cookies(self, cookies):
+    async def set_cookies(self, cookies, context=None):
         await self._done("cookies", [cookie.name for cookie in cookies])
 
-    async def set_local_storage(self, origins):
+    async def set_local_storage(self, origins, context=None):
         await self._done("local_storage", [origin.origin for origin in origins])
 
-    async def replace_tabs(self, tabs):
+    async def replace_tabs(self, tabs, context=None):
         await self._done("tabs", [(tab.url, tab.active) for tab in tabs])
 
     async def load_start_tabs(self, urls, site_of, own_timeout_s, live_timeout_s):
@@ -149,7 +152,8 @@ async def test_data_get_is_its_state_its_profile_without_caches_or_locks_and_its
 
     state = json.loads(files.pop("browser-state.json"))
     assert json.loads(files.pop("network.har"))["log"]["entries"] == []
-    assert set(state) == {"cookies", "local_storage", "tabs", "closed_tabs", "downloads", "clock", "start_tabs"}
+    assert set(state) == {"cookies", "local_storage", "tabs", "closed_tabs", "downloads", "clock", "start_tabs",
+                          "contexts"}
     assert state["cookies"] == FakeControl().cookie_list and "partitionKey" not in state["cookies"][0]
     assert state["clock"]["mode"] == "real" and state["tabs"][0]["id"] == "t1" and state["closed_tabs"][0]["id"] == "t0"
     assert files == {f"{PROFILE}/Default/Cookies": b"db", f"{PROFILE}/Default/Cookies-journal": b"j",
diff --git a/packages/agentenv-protocol/tests/test_browser_state.py b/packages/agentenv-protocol/tests/test_browser_state.py
index a6f6e67a9..23d154566 100644
--- a/packages/agentenv-protocol/tests/test_browser_state.py
+++ b/packages/agentenv-protocol/tests/test_browser_state.py
@@ -308,7 +308,7 @@ async def test_its_record_and_tab_list_have_the_shapes_and_name_each_tabs_opener
     devtools.send("Target.targetDestroyed", {"targetId": "popup"})
 
     record = await control.record()
-    assert set(record["tabs"][0]) == {"id", "url", "title", "opened_at", "opener", "active"}
+    assert set(record["tabs"][0]) == {"id", "url", "title", "opened_at", "opener", "active", "context"}
     assert record["tabs"][0]["opener"] is None
     assert (record["closed_tabs"][0]["opener"], record["closed_tabs"][0]["closed_by"]) == ("a", "unknown")
     assert (await control.tab_list())[0]["id"] == "a"
diff --git a/src/agent_env/browsers/README.md b/src/agent_env/browsers/README.md
index 68fa1ddaa..5b4ea8b97 100644
--- a/src/agent_env/browsers/README.md
+++ b/src/agent_env/browsers/README.md
@@ -48,7 +48,13 @@ values, the origin's other keys left as they are; `browser_clear_local_storage {
 `browser_open_tab {url, background?}`, in front, or with `background` behind the active tab, which stays active; and
 `browser_close_tab {url}` and `browser_activate_tab {url}`, on the one open tab at that URL as the browser shows it
 (scheme and host lowercase, no default port, `/` for an empty path), none or several failing the step with the tabs
-open listed. `browser_sign_in {site, user}` signs the browser in to `site`, a website env deployed in the run on its
+open listed. `browser_lease_context {label, grants?}` leases a context of the browser's beside its default one, its own
+cookies, local storage, tabs and downloads (in `~/Contexts/<label>/Downloads`), recorded as granted to the agents
+`grants` names, which nothing enforces yet; leasing a label again finds the same lease. Each step above, and
+`browser_sign_in`, takes a `context`, a lease's label, to act in it instead of the default context.
+`browser_release_context {label}` ends a lease, closing its tabs and deleting its folder; a reset or relaunch of the
+browser ends every lease, so a task leases again after `reset_env`. A context an agent makes over its CDP address is
+leased to it as `agent-<agent name>-<n>`, and only that agent may dispose it. `browser_sign_in {site, user}` signs the browser in to `site`, a website env deployed in the run on its
 own or in a multi env, by its env id: the site's `website/v1` `session {user}` gives the cookies and local storage,
 each cookie is set for every name the site is reached by (an exact name by its URL, a `*.` name as a domain cookie),
 and the browser's `data/add` loads them, which opens the start tabs again while no agent has acted. A task runs it
diff --git a/src/agent_env/task/episode/rules.py b/src/agent_env/task/episode/rules.py
index 70e882d90..943f7c010 100644
--- a/src/agent_env/task/episode/rules.py
+++ b/src/agent_env/task/episode/rules.py
@@ -154,10 +154,10 @@ def _rubrics_verifier(step: RubricsVerifierTaskStep, outside: Outside) -> list[s
 UNAFFECTED = frozenset({
     # They name no agent.
     "aggregate_verifiers", "apply_server_config", "browser_activate_tab", "browser_clear_local_storage",
-    "browser_close_tab", "browser_delete_cookies", "browser_open_tab", "browser_set_cookies", "browser_sign_in",
-    "browser_set_local_storage", "build_mcp_cli", "combine_universe_verdicts", "configure_scheduled_checks",
-    "deploy_env", "deploy_sandbox", "end_browser_recording", "end_computer_recording", "start_browser_recording",
-    "start_computer_recording", "env_outcome_verifier",
+    "browser_close_tab", "browser_delete_cookies", "browser_lease_context", "browser_open_tab",
+    "browser_release_context", "browser_set_cookies", "browser_sign_in", "browser_set_local_storage", "build_mcp_cli",
+    "combine_universe_verdicts", "configure_scheduled_checks", "deploy_env", "deploy_sandbox", "end_browser_recording",
+    "end_computer_recording", "start_browser_recording", "start_computer_recording", "env_outcome_verifier",
     "modify_env_tool_access", "reset_env", "review",
     "run_container_unit_tests_verifier", "run_docker_container", "snapshot_env", "snapshot_computer_env", "sync_env_clock",
     "validation_gate_aggregator", "verify_env_card", "verify_env_core_protocol", "verify_mcp_tool_schema",
diff --git a/src/agent_env/task_step/registry.py b/src/agent_env/task_step/registry.py
index 97af2c528..fae8cdf0d 100644
--- a/src/agent_env/task_step/registry.py
+++ b/src/agent_env/task_step/registry.py
@@ -28,6 +28,10 @@ def get_task_step_registry() -> dict[str, type["TaskStep"]]:
 
 def _builtin_registry() -> dict[str, type["TaskStep"]]:
     from agent_env.task_step.task_steps.browser.connect_cdp import BrowserConnectCdpTaskStep
+    from agent_env.task_step.task_steps.browser.contexts import (
+        BrowserLeaseContextTaskStep,
+        BrowserReleaseContextTaskStep,
+    )
     from agent_env.task_step.task_steps.browser.cookies import BrowserDeleteCookiesTaskStep, BrowserSetCookiesTaskStep
     from agent_env.task_step.task_steps.browser.sign_in import BrowserSignInTaskStep
     from agent_env.task_step.task_steps.browser.local_storage import (
@@ -115,6 +119,8 @@ def _builtin_registry() -> dict[str, type["TaskStep"]]:
         _get_type(BrowserOpenTabTaskStep): BrowserOpenTabTaskStep,
         _get_type(BrowserCloseTabTaskStep): BrowserCloseTabTaskStep,
         _get_type(BrowserActivateTabTaskStep): BrowserActivateTabTaskStep,
+        _get_type(BrowserLeaseContextTaskStep): BrowserLeaseContextTaskStep,
+        _get_type(BrowserReleaseContextTaskStep): BrowserReleaseContextTaskStep,
         _get_type(CollectArtifactsTaskStep): CollectArtifactsTaskStep,
         _get_type(StartComputerRecordingTaskStep): StartComputerRecordingTaskStep,
         _get_type(EndComputerRecordingTaskStep): EndComputerRecordingTaskStep,
diff --git a/src/agent_env/task_step/task_steps/browser/base.py b/src/agent_env/task_step/task_steps/browser/base.py
index e528fdbc6..8e36167bc 100644
--- a/src/agent_env/task_step/task_steps/browser/base.py
+++ b/src/agent_env/task_step/task_steps/browser/base.py
@@ -8,6 +8,7 @@
 
 from agentenv_protocol.client import find_extension, find_extension_method, invoke_extension
 from agentenv_protocol.website_browser import BROWSER
+from agentenv_protocol.website_browser.contexts import label_problem
 
 from agent_env.env.env import DeployedEnv, Env
 from agent_env.env.envs.computer.env import ComputerEnv
@@ -20,17 +21,22 @@
 CALL_TIMEOUT_S = 60
 #: Where the steps record what each found or did, by step id.
 RECORDS_KEY = "browser_steps"
+#: The browser/v1 operation a browser that leases contexts serves, and so takes a ``context`` on its other ops.
+LEASES = "contexts/lease"
 
 
 class BrowserStep(TaskStep):
-    """A step on the website browser in the env ``env_id``: the one ``browser`` names, else the env's only one.
-    Preflight refuses an env that has no browser, or none of that name, or several when it names none."""
+    """A step on the website browser in the env ``env_id``: the one ``browser`` names, else the env's only one; one
+that takes a ``context`` acts in the lease it names, by its label, else in the browser's default context.
+Preflight refuses an env that has no browser, or none of that name, or several when it names none."""
 
     def __init__(self, id: str, version: Optional[int], env_id: str, browser: Optional[str] = None,
-                 depends_on: Optional[list[TaskStepDependency]] = None, fail_task_on_error: bool = True):
+                 depends_on: Optional[list[TaskStepDependency]] = None, fail_task_on_error: bool = True,
+                 context: Optional[str] = None):
         super().__init__(id, version, depends_on=depends_on, fail_task_on_error=fail_task_on_error)
         self.env_id = env_id
         self.browser = browser
+        self.context_label = context
 
     def config_problems(self) -> list[str]:
         problems = []
@@ -38,6 +44,8 @@ def config_problems(self) -> list[str]:
             problems.append(f"step {self.id!r}: env_id must be a non-empty string")
         if self.browser is not None and (not isinstance(self.browser, str) or not self.browser):
             problems.append(f"step {self.id!r}: browser, when given, must be a non-empty string")
+        if self.context_label is not None and (problem := label_problem(self.context_label, by_task=False)):
+            problems.append(f"step {self.id!r}: context: {problem}")
         return problems
 
     def preflight(self) -> list[str]:
@@ -60,12 +68,17 @@ def preflight(self) -> list[str]:
         return problems
 
     def to_dict(self) -> dict:
-        return {**super().to_dict(), "env_id": self.env_id, "browser": self.browser}
+        return {**super().to_dict(), "env_id": self.env_id, "browser": self.browser,
+                **({"context": self.context_label} if self.context_label is not None else {})}
 
     @classmethod
     def _browser_from_dict(cls, data: dict) -> dict:
         return {**cls._base_from_dict(data), "env_id": data["env_id"], "browser": data.get("browser")}
 
+    @classmethod
+    def _in_context_from_dict(cls, data: dict) -> dict:
+        return {**cls._browser_from_dict(data), "context": data.get("context")}
+
     def _find(self, context: TaskStepContext) -> tuple[DeployedEnv, Optional[str], dict]:
         """The record that serves the browser, the deployed env's or a multi env's computer's, and the browser's name,
         None for that record's env itself, and card."""
@@ -73,17 +86,22 @@ def _find(self, context: TaskStepContext) -> tuple[DeployedEnv, Optional[str], d
 
     async def _call(self, context: TaskStepContext, op: str, params: dict,
                     timeout_s: float = CALL_TIMEOUT_S) -> Any:
-        """``op``'s answer from the browser, refused when its card serves no such operation."""
+        """``op``'s answer from the browser, in the step's context when it names one, refused when its card serves no
+        such operation, or none in a context."""
         deployed, name, card = self._find(context)
-        if find_extension_method(card, BROWSER, op) is None:
-            raise RuntimeError(f"the website browser {name or deployed.env_id!r} in env {deployed.env_id!r} serves no "
-                               f"browser/v1 {op}: rebuild it on a newer agentenv-framework-protocol")
+        for needed in [op, *([LEASES] if self.context_label is not None else [])]:
+            if find_extension_method(card, BROWSER, needed) is None:
+                raise RuntimeError(f"the website browser {name or deployed.env_id!r} in env {deployed.env_id!r} serves "
+                                   f"no browser/v1 {needed}: rebuild it on a newer agentenv-framework-protocol")
+        if self.context_label is not None:
+            params = {**params, "context": self.context_label}
         return await invoke_extension(deployed.environment_url, card, BROWSER, params, timeout_s, method=op,
                                       headers=deployed.control_headers)
 
     def _record(self, context: TaskStepContext, **fields: Any) -> None:
-        context.metadata.setdefault(RECORDS_KEY, {})[self.id] = {"env_id": self.env_id, "browser": self.browser,
-                                                                 **fields}
+        context.metadata.setdefault(RECORDS_KEY, {})[self.id] = {
+            "env_id": self.env_id, "browser": self.browser,
+            **({"context": self.context_label} if self.context_label is not None else {}), **fields}
 
 
 def stored_browsers(env: Env) -> list[str]:
diff --git a/src/agent_env/task_step/task_steps/browser/contexts.py b/src/agent_env/task_step/task_steps/browser/contexts.py
new file mode 100644
index 000000000..775d90c7f
--- /dev/null
+++ b/src/agent_env/task_step/task_steps/browser/contexts.py
@@ -0,0 +1,88 @@
+"""browser_lease_context and browser_release_context: a context of its own leased in an env's website browser by a
+label, which the other browser steps act in when they name it as their ``context``, and ended."""
+
+from __future__ import annotations
+
+import logging
+from typing import ClassVar, Optional
+
+from agentenv_protocol.website_browser.contexts import label_problem
+
+from agent_env.entity.refs import EntityRef
+from agent_env.task_step.context import TaskStepContext
+from agent_env.task_step.task_step import TaskStepDependency
+from agent_env.task_step.task_steps.browser.base import BrowserStep
+
+logger = logging.getLogger(__name__)
+
+
+class BrowserLeaseContextTaskStep(BrowserStep):
+    """Lease a context of its own in the browser as ``label``: its own cookies, local storage, tabs and downloads
+    folder, recorded as granted to each agent ``grants`` names, which nothing enforces yet. A label leased before finds
+    that lease, so a retried step is harmless; a reset, or the browser's relaunch, ends every lease."""
+
+    type: ClassVar[str] = "browser_lease_context"
+    entity_refs = (EntityRef.env("env_id"),)
+
+    def __init__(self, id: str, version: Optional[int], env_id: str, label: str, grants: Optional[list[str]] = None,
+                 browser: Optional[str] = None, depends_on: Optional[list[TaskStepDependency]] = None,
+                 fail_task_on_error: bool = True):
+        super().__init__(id, version, env_id, browser, depends_on=depends_on, fail_task_on_error=fail_task_on_error)
+        self.label, self.grants = label, grants if grants is not None else []
+
+    def config_problems(self) -> list[str]:
+        problems = super().config_problems()
+        if problem := label_problem(self.label):
+            problems.append(f"step {self.id!r}: label: {problem}")
+        if not isinstance(self.grants, list) or not all(isinstance(name, str) and name for name in self.grants):
+            problems.append(f"step {self.id!r}: grants, when given, must be a list of agent names")
+        return problems
+
+    def to_dict(self) -> dict:
+        return {**super().to_dict(), "label": self.label, "grants": self.grants}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> BrowserLeaseContextTaskStep:
+        return cls(**cls._browser_from_dict(data), label=data.get("label"), grants=data.get("grants"))
+
+    async def execute(self, context: TaskStepContext) -> TaskStepContext:
+        leased = await self._call(context, "contexts/lease", {"label": self.label})
+        for name in self.grants:
+            await self._call(context, "contexts/grant", {"context": self.label, "user": name})
+        logger.info(f"{self.id}: leased the context {self.label!r} ({leased['id']}) in the browser of env "
+                    f"{self.env_id!r}" + (f", granted to {self.grants}" if self.grants else ""))
+        self._record(context, label=leased["context"], id=leased["id"], grants=list(self.grants))
+        return context
+
+
+class BrowserReleaseContextTaskStep(BrowserStep):
+    """End the lease ``label`` in the browser: its tabs closed and its folder deleted, downloads and all. A label that
+    isn't leased is left as it is, which is recorded, so a retried step is harmless."""
+
+    type: ClassVar[str] = "browser_release_context"
+    entity_refs = (EntityRef.env("env_id"),)
+
+    def __init__(self, id: str, version: Optional[int], env_id: str, label: str, browser: Optional[str] = None,
+                 depends_on: Optional[list[TaskStepDependency]] = None, fail_task_on_error: bool = True):
+        super().__init__(id, version, env_id, browser, depends_on=depends_on, fail_task_on_error=fail_task_on_error)
+        self.label = label
+
+    def config_problems(self) -> list[str]:
+        problems = super().config_problems()
+        if problem := label_problem(self.label, by_task=False):
+            problems.append(f"step {self.id!r}: label: {problem}")
+        return problems
+
+    def to_dict(self) -> dict:
+        return {**super().to_dict(), "label": self.label}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> BrowserReleaseContextTaskStep:
+        return cls(**cls._browser_from_dict(data), label=data.get("label"))
+
+    async def execute(self, context: TaskStepContext) -> TaskStepContext:
+        released = (await self._call(context, "contexts/release", {"context": self.label}))["released"]
+        logger.info(f"{self.id}: {'released' if released else 'found no lease'} {self.label!r} in the browser of env "
+                    f"{self.env_id!r}")
+        self._record(context, label=self.label, released=released)
+        return context
diff --git a/src/agent_env/task_step/task_steps/browser/cookies.py b/src/agent_env/task_step/task_steps/browser/cookies.py
index 93e440d80..9f4b33cf4 100644
--- a/src/agent_env/task_step/task_steps/browser/cookies.py
+++ b/src/agent_env/task_step/task_steps/browser/cookies.py
@@ -17,16 +17,18 @@
 
 
 class BrowserSetCookiesTaskStep(BrowserStep):
-    """Set ``cookies`` in the browser, all or none, each in the shape cookies/set takes: a ``url``, or a ``domain`` and
-    ``path``, and ``max_age`` in place of ``expires`` for a lifetime from when it's set."""
+    """Set ``cookies`` in the browser, or the lease ``context`` names, all or none, each in the shape cookies/set
+    takes: a ``url``, or a ``domain`` and ``path``, and ``max_age`` in place of ``expires`` for a lifetime from when
+    it's set."""
 
     type: ClassVar[str] = "browser_set_cookies"
     entity_refs = (EntityRef.env("env_id"),)
 
     def __init__(self, id: str, version: Optional[int], env_id: str, cookies: list[dict],
                  browser: Optional[str] = None, depends_on: Optional[list[TaskStepDependency]] = None,
-                 fail_task_on_error: bool = True):
-        super().__init__(id, version, env_id, browser, depends_on=depends_on, fail_task_on_error=fail_task_on_error)
+                 fail_task_on_error: bool = True, context: Optional[str] = None):
+        super().__init__(id, version, env_id, browser, depends_on=depends_on, fail_task_on_error=fail_task_on_error,
+                         context=context)
         self.cookies = cookies
 
     def config_problems(self) -> list[str]:
@@ -47,7 +49,7 @@ def to_dict(self) -> dict:
 
     @classmethod
     def from_dict(cls, data: dict) -> BrowserSetCookiesTaskStep:
-        return cls(**cls._browser_from_dict(data), cookies=data["cookies"])
+        return cls(**cls._in_context_from_dict(data), cookies=data["cookies"])
 
     async def execute(self, context: TaskStepContext) -> TaskStepContext:
         await self._call(context, "cookies/set", {"cookies": self.cookies})
@@ -65,8 +67,10 @@ class BrowserDeleteCookiesTaskStep(BrowserStep):
 
     def __init__(self, id: str, version: Optional[int], env_id: str, name: Optional[str] = None,
                  domain: Optional[str] = None, path: Optional[str] = None, browser: Optional[str] = None,
-                 depends_on: Optional[list[TaskStepDependency]] = None, fail_task_on_error: bool = True):
-        super().__init__(id, version, env_id, browser, depends_on=depends_on, fail_task_on_error=fail_task_on_error)
+                 depends_on: Optional[list[TaskStepDependency]] = None, fail_task_on_error: bool = True,
+                 context: Optional[str] = None):
+        super().__init__(id, version, env_id, browser, depends_on=depends_on, fail_task_on_error=fail_task_on_error,
+                         context=context)
         self.name, self.domain, self.path = name, domain, path
 
     def config_problems(self) -> list[str]:
@@ -82,7 +86,7 @@ def to_dict(self) -> dict:
 
     @classmethod
     def from_dict(cls, data: dict) -> BrowserDeleteCookiesTaskStep:
-        return cls(**cls._browser_from_dict(data), name=data.get("name"), domain=data.get("domain"),
+        return cls(**cls._in_context_from_dict(data), name=data.get("name"), domain=data.get("domain"),
                    path=data.get("path"))
 
     async def execute(self, context: TaskStepContext) -> TaskStepContext:
diff --git a/src/agent_env/task_step/task_steps/browser/local_storage.py b/src/agent_env/task_step/task_steps/browser/local_storage.py
index 5c5462cd7..e0412db95 100644
--- a/src/agent_env/task_step/task_steps/browser/local_storage.py
+++ b/src/agent_env/task_step/task_steps/browser/local_storage.py
@@ -25,8 +25,9 @@ class BrowserSetLocalStorageTaskStep(BrowserStep):
 
     def __init__(self, id: str, version: Optional[int], env_id: str, origin: str, items: dict[str, str],
                  browser: Optional[str] = None, depends_on: Optional[list[TaskStepDependency]] = None,
-                 fail_task_on_error: bool = True):
-        super().__init__(id, version, env_id, browser, depends_on=depends_on, fail_task_on_error=fail_task_on_error)
+                 fail_task_on_error: bool = True, context: Optional[str] = None):
+        super().__init__(id, version, env_id, browser, depends_on=depends_on, fail_task_on_error=fail_task_on_error,
+                         context=context)
         self.origin, self.items = origin, items
 
     def config_problems(self) -> list[str]:
@@ -41,7 +42,7 @@ def to_dict(self) -> dict:
 
     @classmethod
     def from_dict(cls, data: dict) -> BrowserSetLocalStorageTaskStep:
-        return cls(**cls._browser_from_dict(data), origin=data["origin"], items=data["items"])
+        return cls(**cls._in_context_from_dict(data), origin=data["origin"], items=data["items"])
 
     async def execute(self, context: TaskStepContext) -> TaskStepContext:
         await self._call(context, "local_storage/set", {"origins": [{
@@ -59,8 +60,9 @@ class BrowserClearLocalStorageTaskStep(BrowserStep):
 
     def __init__(self, id: str, version: Optional[int], env_id: str, origin: Optional[str] = None,
                  browser: Optional[str] = None, depends_on: Optional[list[TaskStepDependency]] = None,
-                 fail_task_on_error: bool = True):
-        super().__init__(id, version, env_id, browser, depends_on=depends_on, fail_task_on_error=fail_task_on_error)
+                 fail_task_on_error: bool = True, context: Optional[str] = None):
+        super().__init__(id, version, env_id, browser, depends_on=depends_on, fail_task_on_error=fail_task_on_error,
+                         context=context)
         self.origin = origin
 
     def config_problems(self) -> list[str]:
@@ -71,7 +73,7 @@ def to_dict(self) -> dict:
 
     @classmethod
     def from_dict(cls, data: dict) -> BrowserClearLocalStorageTaskStep:
-        return cls(**cls._browser_from_dict(data), origin=data.get("origin"))
+        return cls(**cls._in_context_from_dict(data), origin=data.get("origin"))
 
     async def execute(self, context: TaskStepContext) -> TaskStepContext:
         cleared = (await self._call(context, "local_storage/clear",
diff --git a/src/agent_env/task_step/task_steps/browser/sign_in.py b/src/agent_env/task_step/task_steps/browser/sign_in.py
index 97586cb66..dbbb76273 100644
--- a/src/agent_env/task_step/task_steps/browser/sign_in.py
+++ b/src/agent_env/task_step/task_steps/browser/sign_in.py
@@ -8,6 +8,7 @@
 
 from agentenv_protocol import METHOD_ADD, DataPart, client as protocol_v1
 from agentenv_protocol.website import WEBSITE_EXTENSION_URI
+from agentenv_protocol.website_browser import BROWSER
 
 from agent_env.entity.refs import EntityRef
 from agent_env.env.env import DeployedEnv, Env, website_child
@@ -17,7 +18,7 @@
 from agent_env.task_step.context import TaskStepContext
 from agent_env.task_step.preflight import stored_env
 from agent_env.task_step.task_step import TaskStepDependency
-from agent_env.task_step.task_steps.browser.base import BrowserStep
+from agent_env.task_step.task_steps.browser.base import LEASES, BrowserStep
 
 logger = logging.getLogger(__name__)
 
@@ -29,16 +30,18 @@
 class BrowserSignInTaskStep(BrowserStep):
     """Sign the browser in to the website env ``site``, deployed in the run on its own or in a multi env, as ``user``:
     the site's ``session {user}`` gives the cookies and local storage, each cookie is set for every name the site is
-    reached by, and the browser's ``data/add`` loads them, which opens its start tabs again while no agent has acted.
-    A task runs it after the load that seeds the site, and again after a reset, which starts the browser afresh."""
+    reached by, and the browser's ``data/add`` loads them, which opens its start tabs again while no agent has acted;
+    in the lease ``context`` names, leased if it isn't, they load there and no tabs open again. A task runs it after
+    the load that seeds the site, and again after a reset, which starts the browser afresh and ends every lease."""
 
     type: ClassVar[str] = "browser_sign_in"
     entity_refs = (EntityRef.env("env_id"), EntityRef.env("site"))
 
     def __init__(self, id: str, version: Optional[int], env_id: str, site: str, user: str,
                  browser: Optional[str] = None, depends_on: Optional[list[TaskStepDependency]] = None,
-                 fail_task_on_error: bool = True):
-        super().__init__(id, version, env_id, browser, depends_on=depends_on, fail_task_on_error=fail_task_on_error)
+                 fail_task_on_error: bool = True, context: Optional[str] = None):
+        super().__init__(id, version, env_id, browser, depends_on=depends_on, fail_task_on_error=fail_task_on_error,
+                         context=context)
         self.site = site
         self.user = user
 
@@ -64,7 +67,7 @@ def to_dict(self) -> dict:
 
     @classmethod
     def from_dict(cls, data: dict) -> BrowserSignInTaskStep:
-        return cls(**cls._browser_from_dict(data), site=data.get("site"), user=data.get("user"))
+        return cls(**cls._in_context_from_dict(data), site=data.get("site"), user=data.get("user"))
 
     async def execute(self, context: TaskStepContext) -> TaskStepContext:
         record, child, names = await self._site(context)
@@ -77,7 +80,12 @@ async def execute(self, context: TaskStepContext) -> TaskStepContext:
         if protocol_v1.serves(card, METHOD_ADD) is False:
             raise RuntimeError(f"the website browser {browser or owner.env_id!r} serves no data/add: rebuild it on a "
                                "newer agentenv-framework-protocol")
+        if self.context_label is not None and protocol_v1.find_extension_method(card, BROWSER, LEASES) is None:
+            raise RuntimeError(f"the website browser {browser or owner.env_id!r} leases no contexts: rebuild it on a "
+                               "newer agentenv-framework-protocol")
         state = {"cookies": cookies, "local_storage": session.get("local_storage") or []}
+        if self.context_label is not None:
+            state = {"contexts": {self.context_label: state}}
         await protocol_v1.add_data(_data_plane(owner, browser), [DataPart(data=state)], timeout=ADD_TIMEOUT_S,
                                    headers=owner.control_headers)
         self._record(context, site=self.site, user=self.user,
diff --git a/src/agent_env/task_step/task_steps/browser/tabs.py b/src/agent_env/task_step/task_steps/browser/tabs.py
index 6e855ccbf..6c8039622 100644
--- a/src/agent_env/task_step/task_steps/browser/tabs.py
+++ b/src/agent_env/task_step/task_steps/browser/tabs.py
@@ -29,8 +29,9 @@ class BrowserOpenTabTaskStep(BrowserStep):
 
     def __init__(self, id: str, version: Optional[int], env_id: str, url: str, background: bool = False,
                  browser: Optional[str] = None, depends_on: Optional[list[TaskStepDependency]] = None,
-                 fail_task_on_error: bool = True):
-        super().__init__(id, version, env_id, browser, depends_on=depends_on, fail_task_on_error=fail_task_on_error)
+                 fail_task_on_error: bool = True, context: Optional[str] = None):
+        super().__init__(id, version, env_id, browser, depends_on=depends_on, fail_task_on_error=fail_task_on_error,
+                         context=context)
         self.url, self.background = url, background
 
     def config_problems(self) -> list[str]:
@@ -44,7 +45,7 @@ def to_dict(self) -> dict:
 
     @classmethod
     def from_dict(cls, data: dict) -> BrowserOpenTabTaskStep:
-        return cls(**cls._browser_from_dict(data), url=data["url"], background=data.get("background", False))
+        return cls(**cls._in_context_from_dict(data), url=data["url"], background=data.get("background", False))
 
     async def execute(self, context: TaskStepContext) -> TaskStepContext:
         params = {"url": self.url, **({"background": True} if self.background else {})}
@@ -64,8 +65,10 @@ class _TabAtUrlStep(BrowserStep):
     did: ClassVar[str]
 
     def __init__(self, id: str, version: Optional[int], env_id: str, url: str, browser: Optional[str] = None,
-                 depends_on: Optional[list[TaskStepDependency]] = None, fail_task_on_error: bool = True):
-        super().__init__(id, version, env_id, browser, depends_on=depends_on, fail_task_on_error=fail_task_on_error)
+                 depends_on: Optional[list[TaskStepDependency]] = None, fail_task_on_error: bool = True,
+                 context: Optional[str] = None):
+        super().__init__(id, version, env_id, browser, depends_on=depends_on, fail_task_on_error=fail_task_on_error,
+                         context=context)
         self.url = url
 
     def config_problems(self) -> list[str]:
@@ -76,7 +79,7 @@ def to_dict(self) -> dict:
 
     @classmethod
     def from_dict(cls, data: dict) -> _TabAtUrlStep:
-        return cls(**cls._browser_from_dict(data), url=data["url"])
+        return cls(**cls._in_context_from_dict(data), url=data["url"])
 
     async def execute(self, context: TaskStepContext) -> TaskStepContext:
         tabs = (await self._call(context, "tabs/list", {}))["tabs"]
diff --git a/tst/integration/computer/browser_computer_test.py b/tst/integration/computer/browser_computer_test.py
index 140cf63f9..c577bc311 100644
--- a/tst/integration/computer/browser_computer_test.py
+++ b/tst/integration/computer/browser_computer_test.py
@@ -109,6 +109,7 @@
 from agent_env.task_step.task_steps.load_artifact import LoadArtifactTaskStep
 from agent_env.task_step.task_steps.prompt_agent import PromptAgentTaskStep
 from agent_env.task_step.task_steps.reset_env import ResetEnvTaskStep
+from tst.integration.computer.browser_contexts import check_browser_contexts
 from tst.integration.computer.browser_data import SITE as DATA_SITE, check_browser_data, check_browser_data_under_chaos
 from tst.integration.computer.browser_steps import check_browser_steps
 from tst.integration.computer.browser_state import check_browser_state, check_browser_state_under_chaos
@@ -472,6 +473,27 @@ async def test_its_task_steps_set_cookies_and_storage_open_a_tab_behind_and_acti
     assert not report.failed
 
 
+@pytest.mark.asyncio
+async def test_its_contexts_are_leased_by_steps_and_by_agents_each_with_its_own_state_and_end_with_a_reset(
+        browser_computer):
+    with namespace_routing():
+        deployed = await Env.get(browser_computer.id).deploy(
+            env_params={"app_settings": {"chromium": {"start_urls": [DATA_SITE]}}})
+        context = TaskStepContext(deployed_envs=[deployed])
+        try:
+            await _ready(deployed)
+            card = (await _get(deployed, "/.well-known/agent-env.json")).json()
+            app = next(child for child in card["children_environments"] if child["name"] == "chromium")
+            await check_browser_contexts(
+                deployed, browser_computer.id,
+                lambda op: deployed.environment_url + protocol_v1.find_extension_method(app, BROWSER, op)["endpoint"],
+                f"{deployed.environment_url}/svc/chromium", lambda user: _cdp(deployed, user))
+        finally:
+            report = await teardown_run(context)
+
+    assert not report.failed
+
+
 @pytest.mark.asyncio
 async def test_a_task_pinning_a_version_of_the_browser_passes_preflight_on_it_and_runs_its_steps_through_task_run(
         browser_computer):
diff --git a/tst/integration/computer/browser_contexts.py b/tst/integration/computer/browser_contexts.py
new file mode 100644
index 000000000..862fa817b
--- /dev/null
+++ b/tst/integration/computer/browser_contexts.py
@@ -0,0 +1,183 @@
+"""browser/v1's contexts on a deployed chromium, inside a computer or alone: two leases made by task steps each sign in
+to a loopback site as its own user, by cookies and local storage of its own, in tabs of its own the default context
+doesn't list; five leases of one label at once are one; a lease's download lands in its own folder, listed in it alone;
+a context an agent makes over CDP is leased to it as agent-<user>-<n>, another agent and the task's lease can't be
+disposed by it, its own can; data/get carries each lease, and once agents have acted a load still leases a missing one
+back with its cookies; and a release, then a reset, end them and delete their folders."""
+
+import asyncio
+import base64
+import itertools
+import json
+import time
+from typing import Callable
+
+import httpx
+from websockets.asyncio.client import connect
+
+from agentenv_protocol import client as protocol_v1
+from agentenv_protocol.types import DataPart, uploaded_object_path
+
+from agent_env.env.envs.computer.utils import inside
+from agent_env.task_step.context import TaskStepContext
+from agent_env.task_step.registry import get_task_step_registry
+from agent_env.task_step.task_step import TaskStep
+from tst.integration.computer.browser_data import ORIGIN, POLL_S, SERVE_S, SERVE_SITE, SITE, WAIT_S
+
+#: A loopback server, for the seconds it's given, whose /file is a download.
+FILE_SITE = "http://127.0.0.1:8786/file"
+SERVE_FILE = r"""import http.server, sys, threading, time
+class Page(http.server.BaseHTTPRequestHandler):
+    def do_GET(self):
+        body = b"invoice for the buyer\n"
+        self.send_response(200)
+        self.send_header("Content-Type", "application/octet-stream")
+        self.send_header("Content-Disposition", "attachment; filename=invoice.txt")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+    def log_message(self, *args):
+        pass
+server = http.server.ThreadingHTTPServer(("127.0.0.1", 8786), Page)
+threading.Thread(target=server.serve_forever, daemon=True).start()
+time.sleep(float(sys.argv[1]))
+"""
+
+
+def _caller(deployed, op_url: Callable[[str], str]):
+    async def call(op: str, params: dict | None = None, *, method: str = "POST", status: int = 200) -> dict:
+        async with httpx.AsyncClient(timeout=120, headers=deployed.control_headers) as http:
+            answer = await (http.get(op_url(op), params=params or {}) if method == "GET"
+                            else http.post(op_url(op), json=params or {}))
+        assert answer.status_code == status, f"{op}: {answer.status_code} {answer.text}"
+        return answer.json()
+
+    return call
+
+
+async def _until(read, holds, what: str):
+    last, deadline = None, time.monotonic() + WAIT_S
+    while time.monotonic() < deadline:
+        last = await read()
+        if holds(last):
+            return last
+        await asyncio.sleep(POLL_S)
+    raise AssertionError(f"{what} didn't happen within {WAIT_S:g} s: {last!r}")
+
+
+async def _cdp_commands(ws_url: str, commands: list[tuple[str, dict]]) -> list[dict]:
+    """Each of ``commands`` sent in order over one CDP connection at ``ws_url``, closed after; each answer."""
+    answers = []
+    async with connect(ws_url, max_size=None, open_timeout=60) as ws:
+        ids = itertools.count(1)
+        for method, params in commands:
+            message_id = next(ids)
+            await ws.send(json.dumps({"id": message_id, "method": method, "params": params}))
+            while (reply := json.loads(await asyncio.wait_for(ws.recv(), 60))).get("id") != message_id:
+                pass
+            answers.append(reply)
+    return answers
+
+
+async def check_browser_contexts(deployed, env_id: str, op_url: Callable[[str], str], data_url: str,
+                                 cdp: Callable[[str], object]) -> None:
+    """The contexts, as the module says, read back through browser/v1 at ``op_url(op)``, its data plane at
+    ``data_url``, and CDP addresses from ``cdp(user)``."""
+    call = _caller(deployed, op_url)
+    context = TaskStepContext(deployed_envs=[deployed])
+
+    def step(type: str, **fields) -> TaskStep:
+        made = get_task_step_registry()[type].from_dict({"id": type, "version": None, "type": type, "env_id": env_id,
+                                                          **fields})
+        assert made.config_problems() + made.preflight() == [], type
+        return made
+
+    async def tabs(label: str | None = None) -> list[dict]:
+        return (await call("tabs/list", {"context": label} if label else None, method="GET"))["tabs"]
+
+    def titled(label: str, title: str):
+        return _until(lambda: tabs(label), lambda found: any(tab["title"] == title for tab in found),
+                      f"a tab of {label} titled {title!r}")
+
+    serving = [asyncio.ensure_future(inside.run(deployed, ["python3", "-c", script, str(SERVE_S)],
+                                                timeout_s=SERVE_S + 60)) for script in (SERVE_SITE, SERVE_FILE)]
+    try:
+        await asyncio.sleep(3)
+        default_before = [tab["id"] for tab in await tabs()]
+        for label, user, theme in (("buyer", "ada", "dark"), ("seller", "bob", None)):
+            context = await step("browser_lease_context", label=label, grants=[user]).execute(context)
+            context = await step("browser_set_cookies", context=label, cookies=[
+                {"name": "sid", "value": label, "url": SITE, "max_age": 3600}]).execute(context)
+            if theme:
+                context = await step("browser_set_local_storage", context=label, origin=ORIGIN,
+                                     items={"theme": theme}).execute(context)
+            context = await step("browser_open_tab", context=label, url=SITE).execute(context)
+        buyer = await titled("buyer", "signed in as buyer theme dark")
+        seller = await titled("seller", "signed in as seller theme none")
+        default_after = [tab["id"] for tab in await tabs()]
+        default_cookies = (await call("cookies/get", {"urls": [SITE]}))["cookies"]
+        raced = await asyncio.gather(*(call("contexts/lease", {"label": "race"}) for _ in range(5)))
+
+        await call("tabs/open", {"url": FILE_SITE, "context": "buyer"})
+        landed = await _until(lambda: call("downloads/list", {"context": "buyer"}, method="GET"),
+                              lambda found: any(d["state"] == "completed" and d.get("size") for d in found["downloads"]),
+                              "the buyer's download")
+        default_downloads = (await call("downloads/list", method="GET"))["downloads"]
+        on_disk = (await inside.run(deployed, ["sh", "-c", "cat ~/Contexts/buyer/Downloads/invoice.txt; ls ~/Downloads"],
+                                    timeout_s=30))["stdout"]
+
+        ada, bob = (await cdp("ada"))["ws_url"], (await cdp("bob"))["ws_url"]
+        [made] = await _cdp_commands(ada, [("Target.createBrowserContext", {})])
+        agents = made["result"]["browserContextId"]
+        listed = (await call("contexts/list", method="GET"))["contexts"]
+        buyer_id = next(lease["id"] for lease in listed if lease["context"] == "buyer")
+        [theirs] = await _cdp_commands(bob, [("Target.disposeBrowserContext", {"browserContextId": agents})])
+        tasks, own = await _cdp_commands(ada, [("Target.disposeBrowserContext", {"browserContextId": buyer_id}),
+                                               ("Target.disposeBrowserContext", {"browserContextId": agents})])
+        after_dispose = [lease["context"] for lease in (await call("contexts/list", method="GET"))["contexts"]]
+
+        state = await _state(deployed, data_url)
+        context = await step("browser_release_context", label="seller").execute(context)
+        released = context.metadata["browser_steps"]["browser_release_context"]["released"]
+        again = await step("browser_release_context", label="seller").execute(context)
+        seller_folder = (await inside.run(deployed, ["sh", "-c", "test -e ~/Contexts/seller && echo kept || echo gone"],
+                                          timeout_s=30))["stdout"].strip()
+        await protocol_v1.add_data(data_url, [DataPart(data={"contexts": {"seller": {
+            "cookies": [{"name": "sid", "value": "seller", "url": SITE}]}}})], timeout=120,
+            headers=deployed.control_headers)
+        await call("tabs/open", {"url": SITE, "context": "seller"})
+        reloaded = await titled("seller", "signed in as seller theme none")
+    finally:
+        for task in serving:
+            task.cancel()
+    await protocol_v1.reset_data(data_url, timeout=300, headers=deployed.control_headers)
+    after_reset = (await call("contexts/list", method="GET"))["contexts"]
+    folders_after_reset = (await inside.run(deployed, ["sh", "-c", "ls ~/Contexts 2>/dev/null | wc -l"],
+                                            timeout_s=30))["stdout"].strip()
+    refused = await call("tabs/list", {"context": "buyer"}, method="GET", status=404)
+
+    assert buyer["context"] == "buyer" and seller["context"] == "seller", (buyer, seller)
+    assert default_after == default_before and default_cookies == [], (default_before, default_after, default_cookies)
+    assert len({answer["id"] for answer in raced}) == 1, raced
+    [download] = [d for d in landed["downloads"] if d["state"] == "completed"]
+    assert download["path"].endswith("/Contexts/buyer/Downloads/invoice.txt") and download["context"] == "buyer"
+    assert default_downloads == [] and on_disk.startswith("invoice for the buyer"), (default_downloads, on_disk)
+    assert {"context": "agent-ada-1", "id": agents, "made_by": "ada", "grants": ["ada"]} in listed, listed
+    assert {"context": "buyer", "id": buyer_id, "made_by": "task", "grants": ["ada"]} in listed, listed
+    assert "is another agent's" in theirs["error"]["message"] and "is the task's" in tasks["error"]["message"]
+    assert "result" in own and sorted(after_dispose) == ["buyer", "race", "seller"], (own, after_dispose)
+    assert state["contexts"]["buyer"]["cookies"][0]["value"] == "buyer", state["contexts"]
+    assert any(path.startswith("Contexts/buyer/Downloads/") for path in state["files"]), state["files"]
+    assert released is True and again.metadata["browser_steps"]["browser_release_context"]["released"] is False
+    assert seller_folder == "gone" and reloaded["context"] == "seller", (seller_folder, reloaded)
+    assert after_reset == [] and folders_after_reset == "0", (after_reset, folders_after_reset)
+    assert "target_unavailable" in json.dumps(refused), refused
+
+
+async def _state(deployed, data_url: str) -> dict:
+    """The browser's data/get state, with the paths of the files it returned beside it."""
+    answer = await protocol_v1.get_data(data_url, timeout=300, headers=deployed.control_headers)
+    paths = [uploaded_object_path(part) for part in answer.parts]
+    [state] = [json.loads(base64.b64decode(part.file.bytes)) for part, path in zip(answer.parts, paths)
+               if path == "browser-state.json"]
+    return {**state, "files": [path for path in paths if path]}
diff --git a/tst/integration/computer/website_browser_test.py b/tst/integration/computer/website_browser_test.py
index 62ea16e7a..279ff8854 100644
--- a/tst/integration/computer/website_browser_test.py
+++ b/tst/integration/computer/website_browser_test.py
@@ -155,7 +155,8 @@ async def test_chromium_runs_with_agentenvs_flags_on_its_pipe_and_a_reset_relaun
         policies["stdout"]).items()
     params = protocol_v1.extension_params(card, BROWSER)
     assert (params["chromium"], params["clock"], sorted(params["methods"])) == (
-        "156.0.8078.4", "real", ["calls/begin", "calls/end", "cdp", "cookies/delete", "cookies/get", "cookies/set",
+        "156.0.8078.4", "real", ["calls/begin", "calls/end", "cdp", "contexts/grant", "contexts/lease",
+                                 "contexts/list", "contexts/release", "cookies/delete", "cookies/get", "cookies/set",
                                  "dialog/answer", "downloads/get", "downloads/list", "files/choose", "history",
                                  "local_storage/clear", "local_storage/get", "local_storage/set", "log", "navigate",
                                  "network", "page/capture", "page/input", "page/state", "page/viewport", "record", "sites/set",
diff --git a/tst/unit/task_step/test_browser_sign_in.py b/tst/unit/task_step/test_browser_sign_in.py
index bcb12cbca..810db87b8 100644
--- a/tst/unit/task_step/test_browser_sign_in.py
+++ b/tst/unit/task_step/test_browser_sign_in.py
@@ -45,7 +45,7 @@ def _browser_card(ops=("cookies/set", "cdp")) -> dict:
                     op: {"endpoint": f"{prefix}/{op}"} for op in ops}}}]}}
 
 
-def _office(*, session: bool = True, card_name: str = "shop") -> DeployedGatewayEnv:
+def _office(*, session: bool = True, card_name: str = "shop", ops=("cookies/set", "cdp")) -> DeployedGatewayEnv:
     """A multi env's record: the shop website among its card's children, served as shop whatever its card names it,
     and the desktop computer, whose card lists chromium, kept whole in its child_envs, as the gateway's card lists the
     computer without its apps."""
@@ -56,7 +56,7 @@ def _office(*, session: bool = True, card_name: str = "shop") -> DeployedGateway
     desktop = DeployedSandboxEnv(
         env_id="desktop-computer", env_version=1, sandbox_id="sb-desktop", sandbox_type="local",
         control_token="desktop-token", environment_card_url=f"{_DESKTOP}/.well-known/agent-env.json",
-        environment_card={"name": "desktop", "children_environments": [_browser_card()]})
+        environment_card={"name": "desktop", "children_environments": [_browser_card(ops)]})
     return DeployedGatewayEnv(
         env_id="office", env_version=1, sandbox_id="gw", sandbox_type="local", gateway_url=_GATEWAY,
         control_token="gateway-token", environment_card_url=f"{_GATEWAY}/.well-known/agent-env.json",
@@ -108,6 +108,23 @@ async def test_a_browser_in_a_multi_envs_computer_is_signed_in_with_the_sites_se
         "names": ["shop.test", "*.shop.test"]}
 
 
+@pytest.mark.asyncio
+async def test_a_browser_signed_in_in_a_context_loads_the_session_into_that_lease_and_one_that_leases_none_is_refused(
+        served):
+    leases = TaskStepContext(deployed_envs=[_office(ops=("cookies/set", "cdp", "contexts/lease"))], metadata={})
+    step = BrowserSignInTaskStep(id="in", version=None, env_id="office", site="shop-site", user="alex",
+                                 context="buyer")
+
+    await step.execute(leases)
+    with pytest.raises(RuntimeError, match="leases no contexts"):
+        await step.execute(TaskStepContext(deployed_envs=[_office()], metadata={}))
+
+    [loaded] = json.loads(served[1].content)["params"]["parts"]
+    assert list(loaded["data"]) == ["contexts"] and set(loaded["data"]["contexts"]["buyer"]) == {"cookies",
+                                                                                                 "local_storage"}
+    assert leases.metadata["browser_steps"]["in"]["context"] == "buyer" and len(served) == 3
+
+
 @pytest.mark.asyncio
 @pytest.mark.parametrize(("stored", "names"), [(["shop.test"], ["shop.test"]), ([], ["shop.example"])],
                          ids=["the-names-it-stores", "the-names-its-card-declares"])
diff --git a/tst/unit/task_step/test_browser_steps.py b/tst/unit/task_step/test_browser_steps.py
index eae52b143..a02acbd75 100644
--- a/tst/unit/task_step/test_browser_steps.py
+++ b/tst/unit/task_step/test_browser_steps.py
@@ -19,6 +19,7 @@
 from agent_env.task_step.context import TaskStepContext
 from agent_env.task_step.registry import get_task_step_registry
 from agent_env.task_step import preflight
+from agent_env.task_step.task_steps.browser.contexts import BrowserLeaseContextTaskStep, BrowserReleaseContextTaskStep
 from agent_env.task_step.task_steps.browser.cookies import BrowserDeleteCookiesTaskStep, BrowserSetCookiesTaskStep
 from agent_env.task_step.task_steps.browser.local_storage import (BrowserClearLocalStorageTaskStep,
                                                                    BrowserSetLocalStorageTaskStep)
@@ -28,7 +29,7 @@
 _ENV = "http://localhost:41000"
 _PREFIX = "/svc/chromium/agentenv/ext/browser"
 _OPS = ("cookies/set", "cookies/delete", "local_storage/set", "local_storage/clear", "tabs/open", "tabs/list",
-        "tabs/close", "tabs/activate")
+        "tabs/close", "tabs/activate", "contexts/lease", "contexts/grant", "contexts/release")
 _TABS = [{"id": "A", "url": "https://shop.test/", "active": True}, {"id": "B", "url": "https://shop.test/orders?page=2",
                                                                       "active": False}]
 
@@ -99,6 +100,43 @@ async def test_no_tab_or_several_at_a_tab_steps_url_fail_it_naming_the_tabs_open
     assert [str(request.url) for request in sent] == [f"{_ENV}{_PREFIX}/tabs/list"]
 
 
+@pytest.mark.asyncio
+async def test_a_lease_step_leases_and_grants_and_a_release_step_ends_it(monkeypatch):
+    sent = _mock(monkeypatch)
+    context = TaskStepContext(deployed_envs=[_env()], metadata={})
+
+    await BrowserLeaseContextTaskStep(id="l", version=None, env_id="computer", label="buyer",
+                                      grants=["ada", "bob"]).execute(context)
+    await BrowserReleaseContextTaskStep(id="r", version=None, env_id="computer", label="buyer").execute(context)
+
+    assert [(request.url.path.removeprefix(f"{_PREFIX}/"), json.loads(request.content)) for request in sent] == [
+        ("contexts/lease", {"label": "buyer"}), ("contexts/grant", {"context": "buyer", "user": "ada"}),
+        ("contexts/grant", {"context": "buyer", "user": "bob"}), ("contexts/release", {"context": "buyer"})]
+    assert context.metadata["browser_steps"] == {
+        "l": {"env_id": "computer", "browser": None, "label": "buyer", "id": "C1", "grants": ["ada", "bob"]},
+        "r": {"env_id": "computer", "browser": None, "label": "buyer", "released": True}}
+
+
+@pytest.mark.asyncio
+async def test_a_step_that_names_a_context_acts_in_it_and_a_browser_that_leases_none_is_refused(monkeypatch):
+    sent = _mock(monkeypatch)
+    context = TaskStepContext(deployed_envs=[_env()], metadata={})
+
+    await BrowserSetCookiesTaskStep(id="s", version=None, env_id="computer", context="buyer", cookies=[
+        {"name": "sid", "value": "ada", "url": "https://shop.test/"}]).execute(context)
+    await BrowserCloseTabTaskStep(id="c", version=None, env_id="computer", url="https://shop.test/",
+                                  context="buyer").execute(context)
+    old = _env(ops=[op for op in _OPS if not op.startswith("contexts/")])
+    with pytest.raises(RuntimeError, match="serves no browser/v1 contexts/lease"):
+        await BrowserOpenTabTaskStep(id="o", version=None, env_id="computer", url="https://shop.test/",
+                                     context="buyer").execute(TaskStepContext(deployed_envs=[old], metadata={}))
+
+    assert json.loads(sent[0].content)["context"] == "buyer"
+    assert sent[1].url.params.get("context") == "buyer" and json.loads(sent[2].content) == {"tab": "A",
+                                                                                           "context": "buyer"}
+    assert len(sent) == 3 and context.metadata["browser_steps"]["c"]["context"] == "buyer"
+
+
 @pytest.mark.asyncio
 async def test_a_browser_whose_card_lacks_the_operation_or_isnt_there_is_refused_before_any_call(monkeypatch):
     sent = _mock(monkeypatch)
@@ -163,6 +201,15 @@ def get(env_id, version=None):
     (BrowserCloseTabTaskStep(id="s", version=None, env_id="computer", url="https://shop.test:port/", browser=""),
      ["step 's': browser, when given, must be a non-empty string",
       "step 's': url 'https://shop.test:port/' isn't a URL: Port could not be cast to integer value as 'port'"]),
+    (BrowserOpenTabTaskStep(id="s", version=None, env_id="computer", url="https://shop.test/", context="Buyer"),
+     ["step 's': context: a context's label is lowercase letters, digits and '-', not at either end, at most 40 "
+      "characters, not 'Buyer'"]),
+    (BrowserLeaseContextTaskStep(id="s", version=None, env_id="computer", label="agent-ada-1", grants=[""]),
+     ["step 's': label: a label starting 'agent-' names a context an agent made, so a task's can't: 'agent-ada-1'",
+      "step 's': grants, when given, must be a list of agent names"]),
+    (BrowserReleaseContextTaskStep(id="s", version=None, env_id="computer", label=""),
+     ["step 's': label: a context's label is lowercase letters, digits and '-', not at either end, at most 40 "
+      "characters, not ''"]),
 ])
 def test_fields_that_dont_fit_are_config_problems_and_a_cookies_value_never_shows(step, problems):
     found = step.config_problems()
@@ -181,11 +228,15 @@ def test_fields_that_dont_fit_are_config_problems_and_a_cookies_value_never_show
     BrowserOpenTabTaskStep(id="s", version=None, env_id="computer", url="https://shop.test/", background=True),
     BrowserCloseTabTaskStep(id="s", version=None, env_id="computer", url="https://shop.test/"),
     BrowserActivateTabTaskStep(id="s", version=None, env_id="computer", url="https://shop.test/"),
+    BrowserActivateTabTaskStep(id="s", version=None, env_id="computer", url="https://shop.test/", context="buyer"),
+    BrowserLeaseContextTaskStep(id="s", version=None, env_id="computer", label="buyer", grants=["ada"]),
+    BrowserReleaseContextTaskStep(id="s", version=None, env_id="computer", label="buyer"),
 ])
 def test_each_step_is_registered_and_round_trips(step):
     registered = get_task_step_registry()[step.type]
 
     assert registered is type(step) and registered.from_dict(step.to_dict()).to_dict() == step.to_dict()
+    assert ("context" in step.to_dict()) == (getattr(step, "context_label", None) is not None)
 
 
 @pytest.mark.parametrize(("url", "shown"), [
@@ -242,7 +293,9 @@ def handle(request: httpx.Request) -> httpx.Response:
         sent.append(request)
         op = request.url.path.removeprefix(f"{_PREFIX}/")
         return httpx.Response(200, json={"cookies/delete": {"deleted": 2}, "local_storage/clear": {"origins": []},
-                                         "tabs/open": {"tab": "C"}, "tabs/list": {"tabs": tabs}}.get(op, {}))
+                                         "tabs/open": {"tab": "C"}, "tabs/list": {"tabs": tabs},
+                                         "contexts/lease": {"context": "buyer", "id": "C1"},
+                                         "contexts/release": {"released": True}}.get(op, {}))
 
     monkeypatch.setattr(httpx, "AsyncClient", lambda *a, **k: real(transport=httpx.MockTransport(handle)))
     return sent