diff --git a/AGENTS.md b/AGENTS.md
index f41af15..2795e7b 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -68,6 +68,10 @@ Architecture
  -  *src/mod.ts* - Main entry point, re-exports all public APIs
  -  *src/bot.ts* - Core Bot interface and createBot function
  -  *src/bot-impl.ts* - Internal Bot implementation
+ -  *src/instance.ts* - Instance interface and createInstance function for
+    hosting multiple bots on a single server
+ -  *src/instance-impl.ts* - Internal Instance implementation, which owns
+    the Fedify federation and routes incoming activities to the right bots
  -  *src/session.ts* - Session management for bot operations
  -  *src/message.ts* - Message types and ActivityPub objects (Note, Article,
     etc.)
@@ -80,8 +84,13 @@ Architecture
 
 ### Key concepts
 
- -  *Bot*: The main bot instance created with `createBot()`, handles events
-    and provides session access
+ -  *Instance*: A server hosting one or more bots, created with
+    `createInstance()`; owns the shared infrastructure (KV store, queue,
+    repository, HTTP handling)
+ -  *Bot*: An individual ActivityPub actor created with `createBot()` (which
+    hosts a single bot on a dedicated instance) or `Instance.createBot()`
+    (static bots or dynamic bot groups); handles events and provides session
+    access
  -  *Session*: Scoped bot operations for publishing content and managing state
  -  *Message*: ActivityPub objects like Note, Article, Question with rich text
     support
diff --git a/CHANGES.md b/CHANGES.md
index ad218d7..2bcd40f 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -6,6 +6,103 @@ Version 0.5.0
 
 To be released.
 
+### @fedify/botkit
+
+ -  Added support for hosting multiple bots on a single instance.
+    [[#16], [#24]]
+
+    The new `createInstance()` function creates an *instance* that owns the
+    shared infrastructure (the key–value store, the message queue, the
+    repository, and HTTP handling), on which multiple bots can be hosted,
+    each with its own actor identity and event handlers.
+
+     -  Added `createInstance()` function.
+     -  Added `Instance` interface.
+     -  Added `InstanceWithVoidContextData` interface.
+     -  Added `CreateInstanceOptions` interface.
+     -  Added `Instance.createBot()` method, which creates a static bot from
+        an identifier and a `BotProfile`, or a dynamic `BotGroup` from
+        a `BotDispatcher` function that resolves bots on demand (e.g. one
+        bot per region, backed by a database).
+     -  Added `BotProfile` interface.
+     -  Added `BotDispatcher` type.
+     -  Added `BotGroup` interface.
+     -  Added `CreateBotGroupOptions` interface, whose `mapUsername` option
+        resolves WebFinger usernames to dynamic bot identifiers.
+     -  Added `BotEventHandlers` interface, which `Bot` and `BotGroup` both
+        extend.
+     -  Added `DEFAULT_INSTANCE_ACTOR_IDENTIFIER` constant.  Multi-bot
+        instances expose an instance actor under a reserved identifier,
+        whose key signs shared-inbox related requests; it can be overridden
+        through the `CreateInstanceOptions.instanceActorIdentifier` option.
+     -  Added `@fedify/botkit/instance` module.
+
+    Activities delivered to the shared inbox are routed to the bots they are
+    relevant to: the followed or unfollowed bot, the owner of the liked or
+    replied-to message, mentioned bots, addressed bots, and bots following
+    the author.  Multi-bot instances serve a bot list at the web root and
+    each bot's pages under `/@{username}`.
+
+    The existing `createBot()` function keeps working for single-bot
+    deployments and preserves their behavior, including the web pages served
+    at the root.
+
+ -  The `Repository` interface now stores data for multiple bot actors:
+    every method takes the identifier of the owning bot actor as its first
+    parameter, and data belonging to different identifiers are isolated from
+    each other.  This is a breaking change for custom `Repository`
+    implementations.  [[#16], [#24]]
+
+     -  Added `identifier` parameter to all `Repository` methods.
+     -  Added `Repository.findFollowedBots()` method, a reverse lookup
+        answering which bots follow a given actor.
+     -  Added optional `Repository.migrate()` method for adopting data
+        stored by BotKit 0.4 or earlier.
+     -  Added `Repository.forIdentifier()` method and `ActorScopedRepository`
+        class, a view of a repository bound to a single bot actor.
+     -  `KvRepository` now stores data under bot-scoped keys.  Its second
+        constructor parameter is now a `KvRepositoryOptions` object with
+        a single `prefix` option, replacing the removed
+        `KvStoreRepositoryPrefixes` interface.
+     -  `createBot()` migrates data stored by BotKit 0.4 or earlier to the
+        bot-scoped layout on startup.
+
+ -  Local object URIs now carry the identifier of the owning bot actor,
+    e.g. `/ap/actor/{identifier}/note/{id}` instead of `/ap/note/{id}`.
+    URIs in the old format are still recognized in incoming activities and
+    are permanently redirected to their canonical URIs when dereferenced,
+    so links stored by remote servers keep working after an upgrade.
+    [[#16], [#24]]
+
+ -  The `Session.bot` property is now typed as `ReadonlyBot`, a read-only
+    view of the bot's identity and profile, instead of `Bot`.  This is
+    a breaking change for code that reached the full `Bot` through
+    a session; such code should hold on to the `Bot` returned by
+    `createBot()` instead.  [[#16], [#24]]
+
+     -  Added `ReadonlyBot` interface.
+
+[#16]: https://github.com/fedify-dev/botkit/issues/16
+[#24]: https://github.com/fedify-dev/botkit/pull/24
+
+### @fedify/botkit-sqlite
+
+ -  All tables now have a `bot_id` column and composite primary keys, so
+    a single database stores the data of multiple bots.  Opening a database
+    created by version 0.4 or earlier rebuilds the affected tables in place,
+    and `SqliteRepository.migrate()` assigns the carried-over rows to a bot
+    actor identifier; `createBot()` calls it automatically on startup.
+    [[#16], [#24]]
+
+### @fedify/botkit-postgres
+
+ -  All tables now have a `bot_id` column and composite primary keys, so
+    a single schema stores the data of multiple bots.  Initializing a schema
+    created by version 0.4 upgrades it in place, and
+    `PostgresRepository.migrate()` assigns the carried-over rows to a bot
+    actor identifier; `createBot()` calls it automatically on startup.
+    [[#16], [#24]]
+
 
 Version 0.4.3
 -------------
diff --git a/deno.json b/deno.json
index bf78cec..a59272c 100644
--- a/deno.json
+++ b/deno.json
@@ -36,7 +36,7 @@
     "fmt": "deno fmt && deno task hongdown --write",
     "install": "deno cache packages/*/src/*.ts && pnpm install",
     "test": "deno test --allow-read --allow-write --allow-env --allow-net=hollo.social,localhost,127.0.0.1 --parallel",
-    "test:node": "pnpm install && pnpm run -r test",
+    "test:node": "pnpm install && pnpm --filter './packages/*' run build && pnpm run -r test",
     "test-all": {
       "dependencies": ["check", "test", "test:node"]
     },
diff --git a/docs/.vitepress/config.mts b/docs/.vitepress/config.mts
index 1b639bd..2c8242a 100644
--- a/docs/.vitepress/config.mts
+++ b/docs/.vitepress/config.mts
@@ -35,6 +35,7 @@ const concepts = {
   text: "Concepts",
   items: [
     { text: "Bot", link: "/concepts/bot.md" },
+    { text: "Instance", link: "/concepts/instance.md" },
     { text: "Session", link: "/concepts/session.md" },
     { text: "Events", link: "/concepts/events.md" },
     { text: "Message", link: "/concepts/message.md" },
diff --git a/docs/concepts/bot.md b/docs/concepts/bot.md
index 9ff4a57..26a939d 100644
--- a/docs/concepts/bot.md
+++ b/docs/concepts/bot.md
@@ -17,6 +17,11 @@ BotKit also exposes the bot actor's standard ActivityPub collections.  The
 JSON-LD responses of the `outbox` and `followers` collections include the
 [FEP-5711] inverse properties `outboxOf` and `followersOf`.
 
+> [!TIP]
+> A bot created by `createBot()` occupies its whole server.  Since BotKit
+> 0.5.0, a single server can also host multiple bots; see the
+> [*Instance* concept document](./instance.md).
+
 [FEP-5711]: https://w3id.org/fep/5711
 
 
diff --git a/docs/concepts/instance.md b/docs/concepts/instance.md
new file mode 100644
index 0000000..a08075d
--- /dev/null
+++ b/docs/concepts/instance.md
@@ -0,0 +1,399 @@
+---
+description: >-
+  An Instance owns the shared infrastructure and can host multiple bots,
+  each with its own actor identity and event handlers.  Learn how to create
+  an instance, host static and dynamic bots on it, and migrate an existing
+  single-bot deployment.
+---
+
+Instance
+========
+
+*This API is available since BotKit 0.5.0.*
+
+An `Instance` is a server that can host multiple bots.  It owns the shared
+infrastructure: the key–value store, the message queue, the repository, and
+HTTP handling.  Each bot hosted on it has its own actor identity, fediverse
+handle, collections, and event handlers, while all of them share one
+[Fedify federation] under the hood.
+
+If your server hosts a single bot, you don't need this API: `createBot()`
+creates a dedicated instance for the bot internally, and everything described
+in the [*Bot* concept document](./bot.md) keeps working as before.  Reach for
+`createInstance()` when you want several bots, or a whole family of bots
+resolved from a database, to share one process and one domain.
+
+[Fedify federation]: https://fedify.dev/manual/federation
+
+
+Creating an instance
+--------------------
+
+You can create an `Instance` by calling the `createInstance()` function:
+
+~~~~ typescript twoslash
+import { createInstance } from "@fedify/botkit";
+import { MemoryKvStore } from "@fedify/fedify";
+
+const instance = createInstance<void>({
+  kv: new MemoryKvStore(),
+});
+~~~~
+
+The `CreateInstanceOptions` take the infrastructure-related options that
+`createBot()` used to take: `~CreateInstanceOptions.kv`,
+`~CreateInstanceOptions.repository`, `~CreateInstanceOptions.queue`,
+`~CreateInstanceOptions.software`, `~CreateInstanceOptions.behindProxy`, and
+`~CreateInstanceOptions.pages`.  A single repository stores the data of every
+bot hosted on the instance, scoped by their identifiers; see the
+[*Repository* concept document](./repository.md) for details.
+
+Two options are specific to multi-bot instances:
+`~CreateInstanceOptions.instanceActorIdentifier` overrides the reserved
+identifier of [the instance actor](#the-instance-actor), and
+`~CreateInstanceOptions.legacyObjectUris` keeps object URIs from an older
+single-bot deployment working (see [*Migrating a single-bot
+deployment*](#migrating-a-single-bot-deployment)).
+
+Like a `Bot`, an `Instance` has a `~Instance.fetch()` method to be connected
+to the HTTP server:
+
+~~~~ typescript twoslash
+import { createInstance } from "@fedify/botkit";
+import { MemoryKvStore } from "@fedify/fedify";
+
+const instance = createInstance<void>({
+  kv: new MemoryKvStore(),
+});
+// ---cut-before---
+export default instance;  // Deno
+~~~~
+
+
+Static bots
+-----------
+
+The `Instance.createBot()` method creates a bot with a fixed identifier and
+profile, hosted on the instance:
+
+~~~~ typescript twoslash
+import { createInstance, text } from "@fedify/botkit";
+import { MemoryKvStore } from "@fedify/fedify";
+
+const instance = createInstance<void>({
+  kv: new MemoryKvStore(),
+});
+// ---cut-before---
+const greetBot = instance.createBot("greet", {
+  username: "greetbot",
+  name: "Greeting Bot",
+});
+
+greetBot.onFollow = async (session, followRequest) => {
+  await followRequest.accept();
+  await session.publish(text`Welcome, ${followRequest.follower}!`);
+};
+~~~~
+
+The first argument is the bot's internal identifier, which is used for the
+actor URI and *should not* be changed after the bot is federated.  The second
+argument is a `BotProfile`, which takes the profile-related options that
+`createBot()` used to take: `~BotProfile.username`, `~BotProfile.name`,
+`~BotProfile.summary`, `~BotProfile.icon`, `~BotProfile.image`,
+`~BotProfile.properties`, `~BotProfile.class`, and
+`~BotProfile.followerPolicy`.
+
+Identifiers and usernames must be unique across the instance;
+`~Instance.createBot()` throws a `TypeError` on duplicates.
+
+Handler registration works exactly like on a `Bot` created by `createBot()`;
+see the [*Events* concept document](./events.md).  Incoming activities are
+routed to the bots they are relevant to: a `Follow` reaches the followed bot,
+a `Like` reaches the owner of the liked message, a mention reaches the
+mentioned bot, and a message from a followed account reaches the bots that
+follow its author.
+
+
+Dynamic bots
+------------
+
+Passing a function instead of an identifier to `~Instance.createBot()`
+creates a `BotGroup`: a family of bots resolved on demand by
+a `BotDispatcher`.  This suits scenarios like “one bot per region,” where
+thousands of potential bots are backed by a database rather than declared up
+front:
+
+~~~~ typescript twoslash
+declare const db: {
+  getRegion(code: string): Promise<{ name: string } | null>;
+  getWeather(code: string): Promise<string>;
+};
+import { createInstance, text } from "@fedify/botkit";
+import { MemoryKvStore } from "@fedify/fedify";
+
+const instance = createInstance<void>({
+  kv: new MemoryKvStore(),
+});
+// ---cut-before---
+const weatherBots = instance.createBot(async (ctx, identifier) => {
+  // Return null for identifiers this dispatcher doesn't handle:
+  if (!identifier.startsWith("weather_")) return null;
+  const region = await db.getRegion(identifier.slice("weather_".length));
+  if (region == null) return null;
+  return {
+    username: identifier,
+    name: `${region.name} Weather Bot`,
+  };
+});
+
+weatherBots.onMention = async (session, message) => {
+  // session.bot tells which bot is being mentioned:
+  const code = session.bot.identifier.slice("weather_".length);
+  const weather = await db.getWeather(code);
+  await message.reply(text`Current weather: ${weather}`);
+};
+~~~~
+
+The dispatcher is invoked whenever an identifier needs to be resolved, e.g.
+for serving an actor or routing an incoming activity, so it should be fast.
+Resolutions are memoized for the duration of a request, but not across
+requests; look profiles up from a database rather than computing them
+expensively.
+
+Event handlers registered on the group are shared by every bot it resolves,
+and they are read at dispatch time, so the registration order of handlers
+and the first resolution of a bot don't matter.
+
+Static bots take precedence over dynamic ones, and when multiple groups are
+registered, their dispatchers are probed in the order the groups were
+created: a dispatcher that returns `null` passes the identifier on to the
+next group, and an identifier no dispatcher recognizes does not resolve at
+all.
+
+### Usernames of dynamic bots
+
+By default, BotKit assumes that a dynamic bot's username equals its
+identifier, which makes WebFinger lookups (`@weather_kr@your-domain`) work
+without extra configuration.  If your usernames differ from your
+identifiers, provide a `~CreateBotGroupOptions.mapUsername` callback:
+
+~~~~ typescript twoslash
+declare const db: {
+  getRegionByName(name: string): Promise<{ code: string } | null>;
+};
+import { createInstance } from "@fedify/botkit";
+import { MemoryKvStore } from "@fedify/fedify";
+
+const instance = createInstance<void>({
+  kv: new MemoryKvStore(),
+});
+declare function dispatcher(ctx: unknown, identifier: string): null;
+// ---cut-before---
+const weatherBots = instance.createBot(
+  async (ctx, identifier) => {
+    // …resolve the profile from the identifier…
+    return dispatcher(ctx, identifier);
+  },
+  {
+    async mapUsername(ctx, username) {
+      const region = await db.getRegionByName(username);
+      return region == null ? null : `weather_${region.code}`;
+    },
+  },
+);
+~~~~
+
+When both are provided, it is your responsibility to keep the
+identifier-to-profile and username-to-identifier mappings consistent.
+
+### Sessions for dynamic bots
+
+Since a group has no single identifier, `BotGroup.getSession()` takes the
+identifier of the bot to control:
+
+~~~~ typescript twoslash
+declare const dispatcher: import("@fedify/botkit").BotDispatcher<void>;
+import { createInstance, text } from "@fedify/botkit";
+import { MemoryKvStore } from "@fedify/fedify";
+
+const instance = createInstance<void>({
+  kv: new MemoryKvStore(),
+});
+const weatherBots = instance.createBot(dispatcher);
+// ---cut-before---
+const session = await weatherBots.getSession(
+  "https://mydomain",
+  "weather_kr",
+);
+await session.publish(text`It's sunny in Seoul today!`);
+~~~~
+
+It returns a `Promise` since the dispatcher has to resolve the identifier
+first, and it rejects with a `TypeError` when the dispatcher doesn't
+recognize the identifier.
+
+
+Multiple bot groups
+-------------------
+
+An instance can host several bot groups side by side, each serving
+a different kind of bot.  Since a dispatcher that returns `null` passes the
+identifier on to the next group, giving each group its own identifier
+namespace (e.g. a prefix) is all it takes to keep them apart:
+
+~~~~ typescript twoslash
+declare const db: {
+  getRegion(code: string): Promise<{ name: string } | null>;
+  getWeather(code: string): Promise<string>;
+  getTopic(slug: string): Promise<{ name: string } | null>;
+  getHeadlines(slug: string): Promise<string>;
+};
+import { createInstance, text } from "@fedify/botkit";
+import { MemoryKvStore } from "@fedify/fedify";
+
+const instance = createInstance<void>({
+  kv: new MemoryKvStore(),
+});
+// ---cut-before---
+// A static bot for instance-wide announcements:
+const announcements = instance.createBot("announcements", {
+  username: "announcements",
+  name: "Announcements",
+});
+
+// One bot per region, under the weather_ prefix:
+const weatherBots = instance.createBot(async (ctx, identifier) => {
+  if (!identifier.startsWith("weather_")) return null;
+  const region = await db.getRegion(identifier.slice("weather_".length));
+  if (region == null) return null;
+  return { username: identifier, name: `${region.name} Weather Bot` };
+});
+
+// One bot per topic, under the news_ prefix:
+const newsBots = instance.createBot(async (ctx, identifier) => {
+  if (!identifier.startsWith("news_")) return null;
+  const topic = await db.getTopic(identifier.slice("news_".length));
+  if (topic == null) return null;
+  return { username: identifier, name: `${topic.name} News Bot` };
+});
+
+weatherBots.onMention = async (session, message) => {
+  const code = session.bot.identifier.slice("weather_".length);
+  await message.reply(text`Current weather: ${await db.getWeather(code)}`);
+};
+
+newsBots.onMention = async (session, message) => {
+  const slug = session.bot.identifier.slice("news_".length);
+  await message.reply(text`Today's headlines: ${await db.getHeadlines(slug)}`);
+};
+~~~~
+
+Resolving the identifier `news_tech` on this instance walks through the
+registrations in order: it is not a static bot, `weatherBots` returns `null`
+because the prefix doesn't match, and `newsBots` resolves it.  Each group
+keeps its own event handlers, so a mention of `@news_tech@your-domain`
+reaches `newsBots.onMention` only.
+
+Registering any number of groups is allowed and never an error.  BotKit
+cannot tell at registration time whether two arbitrary dispatchers overlap,
+so overlaps are resolved by order instead: if two groups would resolve the
+same identifier, the group created first wins and the later group's
+dispatcher is not even invoked for it.  WebFinger username resolution has
+its own order: static bots' usernames win first, then the groups'
+`~CreateBotGroupOptions.mapUsername` callbacks are tried in creation order,
+and the username-as-identifier fallback for groups without the callback
+comes last.  In practice, disjoint namespaces like the prefixes above are
+the way to keep group boundaries obvious.
+
+
+The instance actor
+------------------
+
+A multi-bot instance has no single obvious actor whose key should sign
+shared-inbox related requests, so it exposes an *instance actor*: an
+internal, non-discoverable `Application` actor, similar to Mastodon's
+instance actor.  It lives under a reserved identifier, which defaults to
+`DEFAULT_INSTANCE_ACTOR_IDENTIFIER` (`__botkit_instance__`).  Bots cannot
+take the reserved identifier, whether they are static or resolved by
+a dispatcher.
+
+In the unlikely case that the default collides with an identifier you need,
+override it through the `~CreateInstanceOptions.instanceActorIdentifier`
+option:
+
+~~~~ typescript twoslash
+import { createInstance } from "@fedify/botkit";
+import { MemoryKvStore } from "@fedify/fedify";
+// ---cut-before---
+const instance = createInstance<void>({
+  kv: new MemoryKvStore(),
+  instanceActorIdentifier: "fetcher",
+});
+~~~~
+
+Like bot identifiers, the instance actor identifier is used for the actor
+URI, so it *should not* be changed after the instance is federated: remote
+servers that have seen the instance actor would no longer be able to fetch
+its key.
+
+Instances created through the single-bot `createBot()` function keep the
+pre-0.5 behavior: the sole bot's key signs shared-inbox requests and no
+instance actor is exposed.
+
+
+Web pages
+---------
+
+A multi-bot instance serves a list of its static bots at the web root, and
+each bot's pages under a path derived from its username:
+
+ -  `/@{username}`: the bot's profile
+ -  `/@{username}/{messageId}`: a message permalink
+ -  `/@{username}/followers`: the bot's followers
+ -  `/@{username}/tags/{hashtag}`: the bot's messages with a hashtag
+ -  `/@{username}/feed.xml`: the bot's Atom feed
+
+Dynamic bots get the same pages once their usernames resolve.  Single-bot
+deployments created through `createBot()` keep serving their pages at the
+web root as before.
+
+
+Custom emojis
+-------------
+
+Custom emojis belong to the instance and are shared by every bot hosted on
+it.  The `Instance.addCustomEmojis()` method works like
+[`Bot.addCustomEmojis()`](./text.md#custom-emojis), and emoji names must be
+unique across the instance.
+
+
+Migrating a single-bot deployment
+---------------------------------
+
+An existing deployment created with `createBot()` keeps working without any
+changes: its data is migrated to the bot-scoped storage layout on startup,
+object URIs in the old format are recognized and redirected, and its web
+pages stay at the root.
+
+If you later want to move a single-bot deployment onto a multi-bot instance,
+two things need to carry over.  First, the repository data: the automatic
+migration runs only in the `createBot()` compatibility path, so either run
+the deployment once with `createBot()` on BotKit 0.5.0 before switching to
+`createInstance()`, or call the repository's `~Repository.migrate()` method
+with the bot's identifier yourself.  Second, the object URIs: create the
+instance with the `~CreateInstanceOptions.legacyObjectUris` option, so that
+object URIs generated by BotKit 0.4 or earlier are still attributed to the
+original bot:
+
+~~~~ typescript twoslash
+import { createInstance } from "@fedify/botkit";
+import { MemoryKvStore } from "@fedify/fedify";
+// ---cut-before---
+const instance = createInstance<void>({
+  kv: new MemoryKvStore(),
+  legacyObjectUris: { identifier: "bot" },
+});
+~~~~
+
+Note that the web page paths change in that case (from `/` to
+`/@{username}`), while actor URIs and follower relationships are preserved.
diff --git a/docs/concepts/repository.md b/docs/concepts/repository.md
index 8c387df..1abf080 100644
--- a/docs/concepts/repository.md
+++ b/docs/concepts/repository.md
@@ -14,6 +14,27 @@ can be used to interact with the database, but you can also create your own
 repositories to interact with other data sources.
 
 
+Bot-scoped storage
+------------------
+
+Since BotKit 0.5.0, a single repository stores the data of every bot hosted
+on an [instance](./instance.md): every `Repository` method takes the
+identifier of the owning bot actor as its first parameter, and data
+belonging to different identifiers are isolated from each other.  The
+`Repository.forIdentifier()` method returns an `ActorScopedRepository`,
+a view of the repository bound to one bot actor, which exposes the same
+operations without the `identifier` parameter.
+
+Custom `Repository` implementations written for BotKit 0.4 or earlier need
+to be updated to the new method signatures.  Besides the added parameter,
+two methods joined the interface: `~Repository.findFollowedBots()`,
+a reverse lookup answering which bots follow a given actor (used for routing
+incoming messages to the right bots), and the optional
+`~Repository.migrate()`, which adopts data stored by BotKit 0.4 or earlier
+for a bot actor identifier.  The built-in repositories migrate legacy data
+automatically when the bot is created through `createBot()`.
+
+
 `KvRepository`
 --------------
 
diff --git a/docs/concepts/session.md b/docs/concepts/session.md
index a29e68f..7866b9a 100644
--- a/docs/concepts/session.md
+++ b/docs/concepts/session.md
@@ -59,6 +59,21 @@ const session = bot.getSession(`https://${SERVER_NAME}`);  // [!code highlight]
 
 :::
 
+> [!NOTE]
+> A dynamic [bot group](./instance.md#dynamic-bots) hosts many bots, so
+> `BotGroup.getSession()` additionally takes the identifier of the bot to
+> control and returns a `Promise`:
+>
+> ~~~~ typescript twoslash
+> import type { BotGroup } from "@fedify/botkit";
+> const weatherBots = {} as unknown as BotGroup<void>;
+> // ---cut-before---
+> const session = await weatherBots.getSession(
+>   "https://mydomain",
+>   "weather_kr",
+> );
+> ~~~~
+
 
 Getting a session from an event handler
 ---------------------------------------
@@ -78,6 +93,32 @@ bot.onMention = async (session, message) => {
 To learn more about event handlers, see the [*Events* section](./events.md).
 
 
+Determining which bot the session belongs to
+--------------------------------------------
+
+The `Session.bot` property is a `ReadonlyBot`: a read-only view of the bot's
+identity and profile, including its `~ReadonlyBot.identifier`,
+`~ReadonlyBot.username`, and `~ReadonlyBot.name`.  It is particularly useful
+in handlers registered on a [dynamic bot group](./instance.md#dynamic-bots),
+where the same handler runs for many bots:
+
+~~~~ typescript twoslash
+import type { BotGroup } from "@fedify/botkit";
+const weatherBots = {} as unknown as BotGroup<void>;
+// ---cut-before---
+weatherBots.onMention = async (session, message) => {
+  const identifier = session.bot.identifier;
+  // …look up the data this particular bot serves…
+};
+~~~~
+
+> [!NOTE]
+> Before BotKit 0.5.0, this property was typed as `Bot`, so event handlers
+> could be reassigned through it.  It is now a `ReadonlyBot`, which exposes
+> the identity and profile only.  If you need the full `Bot`, hold on to
+> the object returned by `createBot()` instead.
+
+
 Determining the actor URI of the bot
 ------------------------------------
 
diff --git a/docs/start.md b/docs/start.md
index 01c87f7..f7f5030 100644
--- a/docs/start.md
+++ b/docs/start.md
@@ -109,6 +109,11 @@ same process for development purposes.
 >  -  [*Key–value store*]
 >  -  [*Message queue*]
 
+> [!TIP]
+> A bot created by `createBot()` occupies its whole server.  If you want to
+> host multiple bots on a single server, create them on an *instance*
+> instead; see the [*Instance* chapter](./concepts/instance.md).
+
 [`MemoryKvStore`]: https://fedify.dev/manual/kv#memorykvstore
 [`InProcessMessageQueue`]: https://fedify.dev/manual/mq#inprocessmessagequeue
 [*Key–value store*]: https://fedify.dev/manual/kv
diff --git a/packages/botkit-postgres/package.json b/packages/botkit-postgres/package.json
index a0f6cfe..fc0a32f 100644
--- a/packages/botkit-postgres/package.json
+++ b/packages/botkit-postgres/package.json
@@ -43,7 +43,7 @@
     "README.md"
   ],
   "peerDependencies": {
-    "@fedify/botkit": "^0.4.0"
+    "@fedify/botkit": "workspace:^"
   },
   "dependencies": {
     "@fedify/fedify": "^2.1.2",
diff --git a/packages/botkit-postgres/src/mod.test.ts b/packages/botkit-postgres/src/mod.test.ts
index 3922974..18c4cff 100644
--- a/packages/botkit-postgres/src/mod.test.ts
+++ b/packages/botkit-postgres/src/mod.test.ts
@@ -122,6 +122,7 @@ if (postgresUrl == null) {
         assert.deepStrictEqual(
           tables.map((row) => row.table_name),
           [
+            "botkit_metadata",
             "follow_requests",
             "followees",
             "followers",
@@ -169,7 +170,7 @@ if (postgresUrl == null) {
           schema: repositorySchema,
           prepare: false,
         });
-        await repo.countMessages();
+        await repo.countMessages("bot");
 
         assert.ok(prepares.length > 0);
         assert.ok(prepares.every((prepare) => !prepare));
@@ -189,7 +190,7 @@ if (postgresUrl == null) {
               sql,
               url: undefined,
               maxConnections: undefined,
-            }]).countMessages(),
+            }]).countMessages("bot"),
         );
         await assert.rejects(
           async () =>
@@ -197,7 +198,7 @@ if (postgresUrl == null) {
               sql,
               url: postgresUrl,
               maxConnections: 1,
-            }]).countMessages(),
+            }]).countMessages("bot"),
           new TypeError(
             "PostgresRepositoryOptions.sql cannot be combined with PostgresRepositoryOptions.url or PostgresRepositoryOptions.maxConnections.",
           ),
@@ -242,7 +243,7 @@ if (postgresUrl == null) {
         }]) as PostgresRepository;
         await waitForMacrotask();
         await assert.rejects(
-          () => repo.countMessages(),
+          () => repo.countMessages("bot"),
           error,
         );
         await waitForMacrotask();
@@ -300,7 +301,7 @@ if (postgresUrl == null) {
                               arrivals < 2 &&
                               query.includes("SELECT follower_id") &&
                               query.includes("FOR UPDATE") &&
-                              parameters?.[0] === followId.href
+                              parameters?.[1] === followId.href
                             ) {
                               arrivals++;
                               if (arrivals === 2) releaseBarrier();
@@ -329,12 +330,12 @@ if (postgresUrl == null) {
         const repoB = new PostgresRepository({ sql: wrapSql(sqlB), schema });
 
         await Promise.all([
-          repoA.addFollower(followId, followerA),
-          repoB.addFollower(followId, followerB),
+          repoA.addFollower("bot", followId, followerA),
+          repoB.addFollower("bot", followId, followerB),
         ]);
 
-        const followers = await Array.fromAsync(repoA.getFollowers());
-        assert.deepStrictEqual(await repoA.countFollowers(), 1);
+        const followers = await Array.fromAsync(repoA.getFollowers("bot"));
+        assert.deepStrictEqual(await repoA.countFollowers("bot"), 1);
         assert.deepStrictEqual(followers.length, 1);
         const remainingFollowerId = followers[0]?.id?.href;
         assert.ok(
@@ -342,11 +343,11 @@ if (postgresUrl == null) {
             remainingFollowerId === followerB.id!.href,
         );
         assert.deepStrictEqual(
-          await repoA.hasFollower(followerA.id!),
+          await repoA.hasFollower("bot", followerA.id!),
           remainingFollowerId === followerA.id!.href,
         );
         assert.deepStrictEqual(
-          await repoA.hasFollower(followerB.id!),
+          await repoA.hasFollower("bot", followerB.id!),
           remainingFollowerId === followerB.id!.href,
         );
       } finally {
@@ -398,7 +399,7 @@ if (postgresUrl == null) {
                           );
                           if (
                             query.includes("pg_advisory_xact_lock") &&
-                            parameters?.[1] === `${schema}:${followId.href}`
+                            parameters?.[1] === `${schema}:bot:${followId.href}`
                           ) {
                             resolveLockAcquired();
                             await barrier;
@@ -420,9 +421,13 @@ if (postgresUrl == null) {
         const repoA = new PostgresRepository({ sql: wrappedSql, schema });
         const repoB = new PostgresRepository({ sql: sqlB, schema });
 
-        const addPromise = repoA.addFollower(followId, follower);
+        const addPromise = repoA.addFollower("bot", followId, follower);
         await lockAcquired;
-        const removePromise = repoB.removeFollower(followId, follower.id!);
+        const removePromise = repoB.removeFollower(
+          "bot",
+          followId,
+          follower.id!,
+        );
         await waitForMacrotask();
         releaseBarrier();
 
@@ -434,8 +439,11 @@ if (postgresUrl == null) {
           await removedFollower?.toJsonLd(),
           await follower.toJsonLd(),
         );
-        assert.deepStrictEqual(await repoA.countFollowers(), 0);
-        assert.deepStrictEqual(await repoA.hasFollower(follower.id!), false);
+        assert.deepStrictEqual(await repoA.countFollowers("bot"), 0);
+        assert.deepStrictEqual(
+          await repoA.hasFollower("bot", follower.id!),
+          false,
+        );
       } finally {
         await adminSql.unsafe(`DROP SCHEMA IF EXISTS "${schema}" CASCADE`);
         await Promise.all([sqlA.end(), sqlB.end(), adminSql.end()]);
@@ -493,7 +501,7 @@ if (postgresUrl == null) {
                               query.includes(
                                 `DELETE FROM "${schema}"."followers"`,
                               ) &&
-                              parameters?.[0] === oldFollower.id!.href
+                              parameters?.[1] === oldFollower.id!.href
                             ) {
                               arrivals++;
                               if (arrivals === 2) releaseBarrier();
@@ -523,23 +531,26 @@ if (postgresUrl == null) {
       try {
         await initializePostgresRepositorySchema(adminSql, schema);
         const setupRepo = new PostgresRepository({ sql: adminSql, schema });
-        await setupRepo.addFollower(followA, oldFollower);
-        await setupRepo.addFollower(followB, oldFollower);
+        await setupRepo.addFollower("bot", followA, oldFollower);
+        await setupRepo.addFollower("bot", followB, oldFollower);
 
         const repoA = new PostgresRepository({ sql: wrapSql(sqlA), schema });
         const repoB = new PostgresRepository({ sql: wrapSql(sqlB), schema });
         await Promise.all([
-          repoA.addFollower(followA, newFollowerA),
-          repoB.addFollower(followB, newFollowerB),
+          repoA.addFollower("bot", followA, newFollowerA),
+          repoB.addFollower("bot", followB, newFollowerB),
         ]);
 
         const followers = await Promise.all(
-          (await Array.fromAsync(repoA.getFollowers())).map((follower) =>
+          (await Array.fromAsync(repoA.getFollowers("bot"))).map((follower) =>
             follower.toJsonLd()
           ),
         );
-        assert.deepStrictEqual(await repoA.countFollowers(), 2);
-        assert.deepStrictEqual(await repoA.hasFollower(oldFollower.id!), false);
+        assert.deepStrictEqual(await repoA.countFollowers("bot"), 2);
+        assert.deepStrictEqual(
+          await repoA.hasFollower("bot", oldFollower.id!),
+          false,
+        );
         assert.deepStrictEqual(followers, [
           await newFollowerA.toJsonLd(),
           await newFollowerB.toJsonLd(),
@@ -599,7 +610,7 @@ if (postgresUrl == null) {
                               query.includes(
                                 `DELETE FROM "${schema}"."followers"`,
                               ) &&
-                              parameters?.[0] === oldFollower.id!.href
+                              parameters?.[1] === oldFollower.id!.href
                             ) {
                               resolveCleanupReady();
                               await Promise.race([
@@ -651,8 +662,8 @@ if (postgresUrl == null) {
                               query.includes(
                                 `INSERT INTO "${schema}"."follow_requests"`,
                               ) &&
-                              parameters?.[0] === followB.href &&
-                              parameters?.[1] === oldFollower.id!.href
+                              parameters?.[1] === followB.href &&
+                              parameters?.[2] === oldFollower.id!.href
                             ) {
                               resolveInsertedNewRequest();
                               await new Promise<void>((resolve) =>
@@ -674,7 +685,7 @@ if (postgresUrl == null) {
       try {
         await initializePostgresRepositorySchema(adminSql, schema);
         const setupRepo = new PostgresRepository({ sql: adminSql, schema });
-        await setupRepo.addFollower(followA, oldFollower);
+        await setupRepo.addFollower("bot", followA, oldFollower);
 
         const repoA = new PostgresRepository({
           sql: wrapCleanupSql(sqlA),
@@ -682,30 +693,37 @@ if (postgresUrl == null) {
         });
         const repoB = new PostgresRepository({ sql: wrapAddSql(sqlB), schema });
 
-        const reassignPromise = repoA.addFollower(followA, reassignedFollower);
+        const reassignPromise = repoA.addFollower(
+          "bot",
+          followA,
+          reassignedFollower,
+        );
         await cleanupReady;
-        const addPromise = repoB.addFollower(followB, oldFollower);
+        const addPromise = repoB.addFollower("bot", followB, oldFollower);
         await Promise.all([reassignPromise, addPromise]);
 
         const followers = await Promise.all(
-          (await Array.fromAsync(repoA.getFollowers())).map((follower) =>
+          (await Array.fromAsync(repoA.getFollowers("bot"))).map((follower) =>
             follower.toJsonLd()
           ),
         );
-        assert.deepStrictEqual(await repoA.countFollowers(), 2);
-        assert.ok(await repoA.hasFollower(oldFollower.id!));
-        assert.ok(await repoA.hasFollower(reassignedFollower.id!));
+        assert.deepStrictEqual(await repoA.countFollowers("bot"), 2);
+        assert.ok(await repoA.hasFollower("bot", oldFollower.id!));
+        assert.ok(await repoA.hasFollower("bot", reassignedFollower.id!));
         assert.deepStrictEqual(followers, [
           await oldFollower.toJsonLd(),
           await reassignedFollower.toJsonLd(),
         ]);
         assert.deepStrictEqual(
-          await (await repoA.removeFollower(followB, oldFollower.id!))
+          await (await repoA.removeFollower("bot", followB, oldFollower.id!))
             ?.toJsonLd(),
           await oldFollower.toJsonLd(),
         );
-        assert.deepStrictEqual(await repoA.countFollowers(), 1);
-        assert.deepStrictEqual(await repoA.hasFollower(oldFollower.id!), false);
+        assert.deepStrictEqual(await repoA.countFollowers("bot"), 1);
+        assert.deepStrictEqual(
+          await repoA.hasFollower("bot", oldFollower.id!),
+          false,
+        );
       } finally {
         await adminSql.unsafe(`DROP SCHEMA IF EXISTS "${schema}" CASCADE`);
         await Promise.all([sqlA.end(), sqlB.end(), adminSql.end()]);
@@ -717,9 +735,9 @@ if (postgresUrl == null) {
       try {
         const repo = harness.repository;
 
-        assert.deepStrictEqual(await repo.getKeyPairs(), undefined);
-        await repo.setKeyPairs(keyPairs);
-        assert.deepStrictEqual(await repo.getKeyPairs(), keyPairs);
+        assert.deepStrictEqual(await repo.getKeyPairs("bot"), undefined);
+        await repo.setKeyPairs("bot", keyPairs);
+        assert.deepStrictEqual(await repo.getKeyPairs("bot"), keyPairs);
 
         const messageA = new Create({
           id: new URL(
@@ -781,13 +799,23 @@ if (postgresUrl == null) {
           updated: Temporal.Instant.from("2025-01-02T12:00:00Z"),
         });
 
-        assert.deepStrictEqual(await repo.countMessages(), 0);
-        await repo.addMessage("01941f29-7c00-7fe8-ab0a-7b593990a3c0", messageA);
-        await repo.addMessage("0194244f-d800-7873-8993-ef71ccd47306", messageB);
-        assert.deepStrictEqual(await repo.countMessages(), 2);
+        assert.deepStrictEqual(await repo.countMessages("bot"), 0);
+        await repo.addMessage(
+          "bot",
+          "01941f29-7c00-7fe8-ab0a-7b593990a3c0",
+          messageA,
+        );
+        await repo.addMessage(
+          "bot",
+          "0194244f-d800-7873-8993-ef71ccd47306",
+          messageB,
+        );
+        assert.deepStrictEqual(await repo.countMessages("bot"), 2);
         assert.deepStrictEqual(
           await Promise.all(
-            (await Array.fromAsync(repo.getMessages({ order: "oldest" }))).map((
+            (await Array.fromAsync(
+              repo.getMessages("bot", { order: "oldest" }),
+            )).map((
               message,
             ) => message.toJsonLd()),
           ),
@@ -796,7 +824,7 @@ if (postgresUrl == null) {
         assert.deepStrictEqual(
           await Promise.all(
             (await Array.fromAsync(
-              repo.getMessages({
+              repo.getMessages("bot", {
                 since: Temporal.Instant.from("2025-01-02T00:00:00Z"),
               }),
             )).map((message) => message.toJsonLd()),
@@ -805,6 +833,7 @@ if (postgresUrl == null) {
         );
         assert.ok(
           await repo.updateMessage(
+            "bot",
             "0194244f-d800-7873-8993-ef71ccd47306",
             async (message) =>
               message.clone({
@@ -814,18 +843,22 @@ if (postgresUrl == null) {
           ),
         );
         assert.deepStrictEqual(
-          await (await repo.getMessage("0194244f-d800-7873-8993-ef71ccd47306"))
+          await (await repo.getMessage(
+            "bot",
+            "0194244f-d800-7873-8993-ef71ccd47306",
+          ))
             ?.toJsonLd(),
           await messageB2.toJsonLd(),
         );
         assert.deepStrictEqual(
           await (await repo.removeMessage(
+            "bot",
             "01941f29-7c00-7fe8-ab0a-7b593990a3c0",
           ))
             ?.toJsonLd(),
           await messageA.toJsonLd(),
         );
-        assert.deepStrictEqual(await repo.countMessages(), 1);
+        assert.deepStrictEqual(await repo.countMessages("bot"), 1);
 
         const followerA = new Person({
           id: new URL("https://example.com/ap/actor/alice"),
@@ -842,58 +875,67 @@ if (postgresUrl == null) {
           "https://example.com/ap/follow/a3d4cc4f-af93-4a9f-a7b3-0b7c0fe4901d",
         );
 
-        await repo.addFollower(followA, followerA);
-        await repo.addFollower(followB, followerB);
-        assert.ok(await repo.hasFollower(followerA.id!));
-        assert.deepStrictEqual(await repo.countFollowers(), 2);
+        await repo.addFollower("bot", followA, followerA);
+        await repo.addFollower("bot", followB, followerB);
+        assert.ok(await repo.hasFollower("bot", followerA.id!));
+        assert.deepStrictEqual(await repo.countFollowers("bot"), 2);
         assert.deepStrictEqual(
           await Promise.all(
-            (await Array.fromAsync(repo.getFollowers({ offset: 1 }))).map((
-              follower,
-            ) => follower.toJsonLd()),
+            (await Array.fromAsync(repo.getFollowers("bot", { offset: 1 })))
+              .map((
+                follower,
+              ) => follower.toJsonLd()),
           ),
           [await followerB.toJsonLd()],
         );
         assert.deepStrictEqual(
-          await repo.removeFollower(followA, followerB.id!),
+          await repo.removeFollower("bot", followA, followerB.id!),
           undefined,
         );
         assert.deepStrictEqual(
-          await (await repo.removeFollower(followA, followerA.id!))?.toJsonLd(),
+          await (await repo.removeFollower("bot", followA, followerA.id!))
+            ?.toJsonLd(),
           await followerA.toJsonLd(),
         );
-        assert.deepStrictEqual(await repo.countFollowers(), 1);
+        assert.deepStrictEqual(await repo.countFollowers("bot"), 1);
 
         const followA2 = new URL(
           "https://example.com/ap/follow/6eedf12f-32aa-4f1d-b6ca-d5bf34c4d149",
         );
-        await repo.addFollower(followA, followerA);
-        await repo.addFollower(followA2, followerA);
-        assert.deepStrictEqual(await repo.countFollowers(), 2);
-        assert.ok(await repo.hasFollower(followerA.id!));
+        await repo.addFollower("bot", followA, followerA);
+        await repo.addFollower("bot", followA2, followerA);
+        assert.deepStrictEqual(await repo.countFollowers("bot"), 2);
+        assert.ok(await repo.hasFollower("bot", followerA.id!));
         assert.deepStrictEqual(
-          await (await repo.removeFollower(followA, followerA.id!))?.toJsonLd(),
+          await (await repo.removeFollower("bot", followA, followerA.id!))
+            ?.toJsonLd(),
           await followerA.toJsonLd(),
         );
-        assert.ok(await repo.hasFollower(followerA.id!));
-        assert.deepStrictEqual(await repo.countFollowers(), 2);
+        assert.ok(await repo.hasFollower("bot", followerA.id!));
+        assert.deepStrictEqual(await repo.countFollowers("bot"), 2);
         assert.deepStrictEqual(
-          await (await repo.removeFollower(followA2, followerA.id!))
+          await (await repo.removeFollower("bot", followA2, followerA.id!))
             ?.toJsonLd(),
           await followerA.toJsonLd(),
         );
-        assert.deepStrictEqual(await repo.countFollowers(), 1);
-        assert.deepStrictEqual(await repo.hasFollower(followerA.id!), false);
+        assert.deepStrictEqual(await repo.countFollowers("bot"), 1);
+        assert.deepStrictEqual(
+          await repo.hasFollower("bot", followerA.id!),
+          false,
+        );
 
-        await repo.addFollower(followA, followerA);
-        assert.deepStrictEqual(await repo.countFollowers(), 2);
-        await repo.addFollower(followA, followerB);
-        assert.deepStrictEqual(await repo.countFollowers(), 1);
-        assert.deepStrictEqual(await repo.hasFollower(followerA.id!), false);
-        assert.ok(await repo.hasFollower(followerB.id!));
+        await repo.addFollower("bot", followA, followerA);
+        assert.deepStrictEqual(await repo.countFollowers("bot"), 2);
+        await repo.addFollower("bot", followA, followerB);
+        assert.deepStrictEqual(await repo.countFollowers("bot"), 1);
+        assert.deepStrictEqual(
+          await repo.hasFollower("bot", followerA.id!),
+          false,
+        );
+        assert.ok(await repo.hasFollower("bot", followerB.id!));
         assert.deepStrictEqual(
           await Promise.all(
-            (await Array.fromAsync(repo.getFollowers())).map((follower) =>
+            (await Array.fromAsync(repo.getFollowers("bot"))).map((follower) =>
               follower.toJsonLd()
             ),
           ),
@@ -908,40 +950,51 @@ if (postgresUrl == null) {
           object: new URL("https://example.com/ap/actor/john"),
         });
         await repo.addSentFollow(
+          "bot",
           "03a395a2-353a-4894-afdb-2cab31a7b004",
           sentFollow,
         );
         assert.deepStrictEqual(
           await (await repo.getSentFollow(
+            "bot",
             "03a395a2-353a-4894-afdb-2cab31a7b004",
           ))
             ?.toJsonLd(),
           await sentFollow.toJsonLd(),
         );
-        await repo.removeSentFollow("03a395a2-353a-4894-afdb-2cab31a7b004");
+        await repo.removeSentFollow(
+          "bot",
+          "03a395a2-353a-4894-afdb-2cab31a7b004",
+        );
         assert.deepStrictEqual(
-          await repo.getSentFollow("03a395a2-353a-4894-afdb-2cab31a7b004"),
+          await repo.getSentFollow(
+            "bot",
+            "03a395a2-353a-4894-afdb-2cab31a7b004",
+          ),
           undefined,
         );
 
         const followeeId = new URL("https://example.com/ap/actor/john");
-        await repo.addFollowee(followeeId, sentFollow);
+        await repo.addFollowee("bot", followeeId, sentFollow);
         assert.deepStrictEqual(
-          await (await repo.getFollowee(followeeId))?.toJsonLd(),
+          await (await repo.getFollowee("bot", followeeId))?.toJsonLd(),
           await sentFollow.toJsonLd(),
         );
-        await repo.removeFollowee(followeeId);
-        assert.deepStrictEqual(await repo.getFollowee(followeeId), undefined);
+        await repo.removeFollowee("bot", followeeId);
+        assert.deepStrictEqual(
+          await repo.getFollowee("bot", followeeId),
+          undefined,
+        );
 
         const messageId = "01945678-1234-7890-abcd-ef0123456789";
         const voter1 = new URL("https://example.com/ap/actor/alice");
         const voter2 = new URL("https://example.com/ap/actor/bob");
-        await repo.vote(messageId, voter1, "option1");
-        await repo.vote(messageId, voter1, "option1");
-        await repo.vote(messageId, voter1, "option2");
-        await repo.vote(messageId, voter2, "option1");
-        assert.deepStrictEqual(await repo.countVoters(messageId), 2);
-        assert.deepStrictEqual(await repo.countVotes(messageId), {
+        await repo.vote("bot", messageId, voter1, "option1");
+        await repo.vote("bot", messageId, voter1, "option1");
+        await repo.vote("bot", messageId, voter1, "option2");
+        await repo.vote("bot", messageId, voter2, "option1");
+        assert.deepStrictEqual(await repo.countVoters("bot", messageId), 2);
+        assert.deepStrictEqual(await repo.countVotes("bot", messageId), {
           "option1": 2,
           "option2": 1,
         });
@@ -952,8 +1005,8 @@ if (postgresUrl == null) {
           schema: harness.schema,
           maxConnections: 1,
         });
-        assert.deepStrictEqual(await repo2.getKeyPairs(), keyPairs);
-        assert.deepStrictEqual(await repo2.countMessages(), 1);
+        assert.deepStrictEqual(await repo2.getKeyPairs("bot"), keyPairs);
+        assert.deepStrictEqual(await repo2.countMessages("bot"), 1);
         await repo2.close();
       } finally {
         await harness.cleanup();
@@ -965,7 +1018,7 @@ if (postgresUrl == null) {
       const sql = createSql(postgresUrl);
       try {
         const repo = new PostgresRepository({ sql, schema });
-        await repo.countMessages();
+        await repo.countMessages("bot");
         await repo.close();
 
         const result = await sql`SELECT 1 AS value`;
@@ -977,3 +1030,381 @@ if (postgresUrl == null) {
     });
   });
 }
+
+if (postgresUrl != null) {
+  describe("PostgresRepository multitenancy", () => {
+    test("isolates data by bot identifier", async () => {
+      const harness = createHarness();
+      try {
+        const repo = harness.repository;
+        const messageId = "01941f29-7c00-7fe8-ab0a-7b593990a3c0" as const;
+        const message = new Create({
+          id: new URL(`https://example.com/ap/actor/botA/create/${messageId}`),
+          actor: new URL("https://example.com/ap/actor/botA"),
+          object: new Note({
+            id: new URL(`https://example.com/ap/actor/botA/note/${messageId}`),
+            content: "Hello, world!",
+          }),
+        });
+        await repo.addMessage("botA", messageId, message);
+        assert.equal(await repo.getMessage("botB", messageId), undefined);
+        assert.equal(await repo.countMessages("botB"), 0);
+        assert.equal(await repo.countMessages("botA"), 1);
+        assert.equal(await repo.removeMessage("botB", messageId), undefined);
+        assert.equal(await repo.countMessages("botA"), 1);
+
+        await repo.setKeyPairs("botA", keyPairs);
+        assert.equal(await repo.getKeyPairs("botB"), undefined);
+        assert.deepStrictEqual(await repo.getKeyPairs("botA"), keyPairs);
+      } finally {
+        await harness.cleanup();
+      }
+    });
+
+    test("findFollowedBots()", async () => {
+      const harness = createHarness();
+      try {
+        const repo = harness.repository;
+        const followeeId = new URL("https://example.com/ap/actor/john");
+        const followA = new Follow({
+          id: new URL(
+            "https://example.com/ap/actor/botA/follow/03a395a2-353a-4894-afdb-2cab31a7b004",
+          ),
+          actor: new URL("https://example.com/ap/actor/botA"),
+          object: followeeId,
+        });
+        const followB = new Follow({
+          id: new URL(
+            "https://example.com/ap/actor/botB/follow/e35ff5d8-ede9-4f5e-9b83-4bfcd4c9a69c",
+          ),
+          actor: new URL("https://example.com/ap/actor/botB"),
+          object: followeeId,
+        });
+        assert.deepStrictEqual(
+          await Array.fromAsync(repo.findFollowedBots(followeeId)),
+          [],
+        );
+        await repo.addFollowee("botA", followeeId, followA);
+        await repo.addFollowee("botB", followeeId, followB);
+        assert.deepStrictEqual(
+          await Array.fromAsync(repo.findFollowedBots(followeeId)),
+          ["botA", "botB"],
+        );
+        await repo.removeFollowee("botA", followeeId);
+        assert.deepStrictEqual(
+          await Array.fromAsync(repo.findFollowedBots(followeeId)),
+          ["botB"],
+        );
+      } finally {
+        await harness.cleanup();
+      }
+    });
+  });
+
+  describe("PostgresRepository legacy schema migration", () => {
+    async function createLegacySchema(
+      sql: postgres.Sql,
+      schema: string,
+    ): Promise<void> {
+      // The schema used by @fedify/botkit-postgres 0.4:
+      await sql.unsafe(`CREATE SCHEMA "${schema}"`);
+      await sql.unsafe(`
+        CREATE TABLE "${schema}"."key_pairs" (
+          position INTEGER PRIMARY KEY,
+          private_key_jwk JSONB NOT NULL,
+          public_key_jwk JSONB NOT NULL
+        )
+      `);
+      await sql.unsafe(`
+        CREATE TABLE "${schema}"."messages" (
+          id TEXT PRIMARY KEY,
+          activity_json JSONB NOT NULL,
+          published BIGINT
+        )
+      `);
+      await sql.unsafe(`
+        CREATE INDEX "idx_messages_published"
+          ON "${schema}"."messages" (published, id)
+      `);
+      await sql.unsafe(`
+        CREATE TABLE "${schema}"."followers" (
+          follower_id TEXT PRIMARY KEY,
+          actor_json JSONB NOT NULL
+        )
+      `);
+      await sql.unsafe(`
+        CREATE TABLE "${schema}"."follow_requests" (
+          follow_request_id TEXT PRIMARY KEY,
+          follower_id TEXT NOT NULL
+            REFERENCES "${schema}"."followers" (follower_id)
+            ON DELETE CASCADE
+        )
+      `);
+      await sql.unsafe(`
+        CREATE INDEX "idx_follow_requests_follower"
+          ON "${schema}"."follow_requests" (follower_id)
+      `);
+      await sql.unsafe(`
+        CREATE TABLE "${schema}"."sent_follows" (
+          id TEXT PRIMARY KEY,
+          follow_json JSONB NOT NULL
+        )
+      `);
+      await sql.unsafe(`
+        CREATE TABLE "${schema}"."followees" (
+          followee_id TEXT PRIMARY KEY,
+          follow_json JSONB NOT NULL
+        )
+      `);
+      await sql.unsafe(`
+        CREATE TABLE "${schema}"."poll_votes" (
+          message_id TEXT NOT NULL,
+          voter_id TEXT NOT NULL,
+          option TEXT NOT NULL,
+          PRIMARY KEY (message_id, voter_id, option)
+        )
+      `);
+      await sql.unsafe(`
+        CREATE INDEX "idx_poll_votes_message_option"
+          ON "${schema}"."poll_votes" (message_id, option)
+      `);
+    }
+
+    async function seedLegacySchema(
+      sql: postgres.Sql,
+      schema: string,
+    ): Promise<{
+      messageId: string;
+      followerId: string;
+      followRequestId: string;
+      followeeId: string;
+      sentFollowId: string;
+    }> {
+      const messageId = "01941f29-7c00-7fe8-ab0a-7b593990a3c0";
+      const message = new Create({
+        id: new URL(`https://example.com/ap/create/${messageId}`),
+        actor: new URL("https://example.com/ap/actor/bot"),
+        object: new Note({
+          id: new URL(`https://example.com/ap/note/${messageId}`),
+          content: "Hello, world!",
+          published: Temporal.Instant.from("2025-01-01T00:00:00Z"),
+        }),
+        published: Temporal.Instant.from("2025-01-01T00:00:00Z"),
+      });
+      await sql.unsafe(
+        `INSERT INTO "${schema}"."messages" (id, activity_json, published)
+         VALUES ($1, $2::jsonb, $3)`,
+        [
+          messageId,
+          JSON.stringify(await message.toJsonLd({ format: "compact" })),
+          Temporal.Instant.from("2025-01-01T00:00:00Z").epochMilliseconds,
+        ],
+      );
+
+      const follower = new Person({
+        id: new URL("https://example.com/ap/actor/john"),
+        preferredUsername: "john",
+      });
+      const followRequestId =
+        "https://example.com/ap/follow/be2da56a-0ea3-4a6a-9dff-2a1837be67e0";
+      await sql.unsafe(
+        `INSERT INTO "${schema}"."followers" (follower_id, actor_json)
+         VALUES ($1, $2::jsonb)`,
+        [
+          follower.id!.href,
+          JSON.stringify(await follower.toJsonLd({ format: "compact" })),
+        ],
+      );
+      await sql.unsafe(
+        `INSERT INTO "${schema}"."follow_requests"
+           (follow_request_id, follower_id)
+         VALUES ($1, $2)`,
+        [followRequestId, follower.id!.href],
+      );
+
+      const followeeId = "https://example.com/ap/actor/jane";
+      const followeeFollow = new Follow({
+        id: new URL(
+          "https://example.com/ap/follow/03a395a2-353a-4894-afdb-2cab31a7b004",
+        ),
+        actor: new URL("https://example.com/ap/actor/bot"),
+        object: new URL(followeeId),
+      });
+      await sql.unsafe(
+        `INSERT INTO "${schema}"."followees" (followee_id, follow_json)
+         VALUES ($1, $2::jsonb)`,
+        [
+          followeeId,
+          JSON.stringify(
+            await followeeFollow.toJsonLd({ format: "compact" }),
+          ),
+        ],
+      );
+
+      const sentFollowId = "e35ff5d8-ede9-4f5e-9b83-4bfcd4c9a69c";
+      const sentFollow = new Follow({
+        id: new URL(`https://example.com/ap/follow/${sentFollowId}`),
+        actor: new URL("https://example.com/ap/actor/bot"),
+        object: new URL("https://example.com/ap/actor/joe"),
+      });
+      await sql.unsafe(
+        `INSERT INTO "${schema}"."sent_follows" (id, follow_json)
+         VALUES ($1, $2::jsonb)`,
+        [
+          sentFollowId,
+          JSON.stringify(await sentFollow.toJsonLd({ format: "compact" })),
+        ],
+      );
+
+      await sql.unsafe(
+        `INSERT INTO "${schema}"."poll_votes" (message_id, voter_id, option)
+         VALUES ($1, $2, $3)`,
+        [messageId, "https://example.com/ap/actor/alice", "option1"],
+      );
+
+      return {
+        messageId,
+        followerId: follower.id!.href,
+        followRequestId,
+        followeeId,
+        sentFollowId,
+      };
+    }
+
+    test("upgrades a legacy schema and adopts its data", async () => {
+      const sql = createSql(postgresUrl!);
+      const schema = createSchemaName();
+      try {
+        await createLegacySchema(sql, schema);
+        const seed = await seedLegacySchema(sql, schema);
+
+        const repo = new PostgresRepository({
+          url: postgresUrl!,
+          schema,
+          maxConnections: 1,
+        });
+        try {
+          assert.equal(await repo.countMessages("bot"), 0);
+
+          await repo.migrate("bot");
+          assert.equal(await repo.countMessages("bot"), 1);
+          assert.ok(
+            await repo.getMessage(
+              "bot",
+              seed
+                .messageId as `${string}-${string}-${string}-${string}-${string}`,
+            ) != null,
+          );
+          assert.ok(await repo.hasFollower("bot", new URL(seed.followerId)));
+          assert.ok(
+            await repo.getFollowee("bot", new URL(seed.followeeId)) != null,
+          );
+          assert.ok(
+            await repo.getSentFollow(
+              "bot",
+              seed
+                .sentFollowId as `${string}-${string}-${string}-${string}-${string}`,
+            ) != null,
+          );
+          assert.equal(
+            await repo.countVoters(
+              "bot",
+              seed
+                .messageId as `${string}-${string}-${string}-${string}-${string}`,
+            ),
+            1,
+          );
+          assert.deepStrictEqual(
+            await Array.fromAsync(
+              repo.findFollowedBots(new URL(seed.followeeId)),
+            ),
+            ["bot"],
+          );
+
+          // removeFollower() exercises the upgraded follow_requests rows:
+          const removed = await repo.removeFollower(
+            "bot",
+            new URL(seed.followRequestId),
+            new URL(seed.followerId),
+          );
+          assert.ok(removed != null);
+
+          // migrate() is idempotent:
+          await repo.migrate("bot");
+          assert.equal(await repo.countMessages("bot"), 1);
+        } finally {
+          await repo.close();
+        }
+
+        // Reopening the upgraded schema works without another upgrade:
+        const repo2 = new PostgresRepository({
+          url: postgresUrl!,
+          schema,
+          maxConnections: 1,
+        });
+        try {
+          assert.equal(await repo2.countMessages("bot"), 1);
+        } finally {
+          await repo2.close();
+        }
+      } finally {
+        await sql.unsafe(`DROP SCHEMA IF EXISTS "${schema}" CASCADE`);
+        await sql.end();
+      }
+    });
+
+    test("survives concurrent initialization", async () => {
+      const sql = createSql(postgresUrl!);
+      const schema = createSchemaName();
+      try {
+        await createLegacySchema(sql, schema);
+        await seedLegacySchema(sql, schema);
+
+        // Two replicas starting at once against the same legacy schema must
+        // both come up; the upgrade is serialized by an advisory lock and
+        // guarded per table:
+        const sqlA = createSql(postgresUrl!);
+        const sqlB = createSql(postgresUrl!);
+        try {
+          await Promise.all([
+            initializePostgresRepositorySchema(sqlA, schema),
+            initializePostgresRepositorySchema(sqlB, schema),
+          ]);
+        } finally {
+          await sqlA.end();
+          await sqlB.end();
+        }
+
+        const repo = new PostgresRepository({
+          url: postgresUrl!,
+          schema,
+          maxConnections: 1,
+        });
+        try {
+          await repo.migrate("bot");
+          assert.equal(await repo.countMessages("bot"), 1);
+        } finally {
+          await repo.close();
+        }
+      } finally {
+        await sql.unsafe(`DROP SCHEMA IF EXISTS "${schema}" CASCADE`);
+        await sql.end();
+      }
+    });
+
+    test("does not reassign data stored under an empty identifier", async () => {
+      const harness = createHarness();
+      try {
+        const repo = harness.repository;
+        // A fresh schema has no legacy marker, so data stored under the
+        // empty-string identifier must never be adopted by migrate():
+        await repo.setKeyPairs("", keyPairs);
+        await repo.migrate("bot");
+        assert.deepStrictEqual(await repo.getKeyPairs(""), keyPairs);
+        assert.equal(await repo.getKeyPairs("bot"), undefined);
+      } finally {
+        await harness.cleanup();
+      }
+    });
+  });
+}
diff --git a/packages/botkit-postgres/src/mod.ts b/packages/botkit-postgres/src/mod.ts
index 7006ecc..f02f56b 100644
--- a/packages/botkit-postgres/src/mod.ts
+++ b/packages/botkit-postgres/src/mod.ts
@@ -13,11 +13,12 @@
 //
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
-import type {
-  Repository,
-  RepositoryGetFollowersOptions,
-  RepositoryGetMessagesOptions,
-  Uuid,
+import {
+  ActorScopedRepository,
+  type Repository,
+  type RepositoryGetFollowersOptions,
+  type RepositoryGetMessagesOptions,
+  type Uuid,
 } from "@fedify/botkit/repository";
 import { exportJwk, importJwk } from "@fedify/fedify/sig";
 import { Temporal, toTemporalInstant } from "@js-temporal/polyfill";
@@ -44,6 +45,7 @@ const logger = getLogger(["botkit", "postgres"]);
 const schemaNamePattern = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const followRequestAdvisoryLockNamespace = 0x4254;
 const followerAdvisoryLockNamespace = 0x4246;
+const schemaUpgradeAdvisoryLockNamespace = 0x424b;
 
 type Queryable = Pick<postgres.Sql, "unsafe">;
 type QueryParameter = postgres.SerializableParameter;
@@ -137,12 +139,24 @@ export async function initializePostgresRepositorySchema(
     [],
     prepare,
   );
+  await upgradeLegacySchema(sql, validatedSchema, prepare);
+  await execute(
+    sql,
+    `CREATE TABLE IF NOT EXISTS "${validatedSchema}"."botkit_metadata" (
+       "key" TEXT PRIMARY KEY,
+       value TEXT NOT NULL
+     )`,
+    [],
+    prepare,
+  );
   await execute(
     sql,
     `CREATE TABLE IF NOT EXISTS "${validatedSchema}"."key_pairs" (
-       position INTEGER PRIMARY KEY,
+       bot_id TEXT NOT NULL,
+       position INTEGER NOT NULL,
        private_key_jwk JSONB NOT NULL,
-       public_key_jwk JSONB NOT NULL
+       public_key_jwk JSONB NOT NULL,
+       PRIMARY KEY (bot_id, position)
      )`,
     [],
     prepare,
@@ -150,9 +164,11 @@ export async function initializePostgresRepositorySchema(
   await execute(
     sql,
     `CREATE TABLE IF NOT EXISTS "${validatedSchema}"."messages" (
-       id TEXT PRIMARY KEY,
+       bot_id TEXT NOT NULL,
+       id TEXT NOT NULL,
        activity_json JSONB NOT NULL,
-       published BIGINT
+       published BIGINT,
+       PRIMARY KEY (bot_id, id)
      )`,
     [],
     prepare,
@@ -160,15 +176,17 @@ export async function initializePostgresRepositorySchema(
   await execute(
     sql,
     `CREATE INDEX IF NOT EXISTS "idx_messages_published"
-       ON "${validatedSchema}"."messages" (published, id)`,
+       ON "${validatedSchema}"."messages" (bot_id, published, id)`,
     [],
     prepare,
   );
   await execute(
     sql,
     `CREATE TABLE IF NOT EXISTS "${validatedSchema}"."followers" (
-       follower_id TEXT PRIMARY KEY,
-       actor_json JSONB NOT NULL
+       bot_id TEXT NOT NULL,
+       follower_id TEXT NOT NULL,
+       actor_json JSONB NOT NULL,
+       PRIMARY KEY (bot_id, follower_id)
      )`,
     [],
     prepare,
@@ -176,10 +194,14 @@ export async function initializePostgresRepositorySchema(
   await execute(
     sql,
     `CREATE TABLE IF NOT EXISTS "${validatedSchema}"."follow_requests" (
-       follow_request_id TEXT PRIMARY KEY,
-       follower_id TEXT NOT NULL
-         REFERENCES "${validatedSchema}"."followers" (follower_id)
+       bot_id TEXT NOT NULL,
+       follow_request_id TEXT NOT NULL,
+       follower_id TEXT NOT NULL,
+       PRIMARY KEY (bot_id, follow_request_id),
+       FOREIGN KEY (bot_id, follower_id)
+         REFERENCES "${validatedSchema}"."followers" (bot_id, follower_id)
          ON DELETE CASCADE
+         DEFERRABLE INITIALLY IMMEDIATE
      )`,
     [],
     prepare,
@@ -187,15 +209,17 @@ export async function initializePostgresRepositorySchema(
   await execute(
     sql,
     `CREATE INDEX IF NOT EXISTS "idx_follow_requests_follower"
-       ON "${validatedSchema}"."follow_requests" (follower_id)`,
+       ON "${validatedSchema}"."follow_requests" (bot_id, follower_id)`,
     [],
     prepare,
   );
   await execute(
     sql,
     `CREATE TABLE IF NOT EXISTS "${validatedSchema}"."sent_follows" (
-       id TEXT PRIMARY KEY,
-       follow_json JSONB NOT NULL
+       bot_id TEXT NOT NULL,
+       id TEXT NOT NULL,
+       follow_json JSONB NOT NULL,
+       PRIMARY KEY (bot_id, id)
      )`,
     [],
     prepare,
@@ -203,19 +227,29 @@ export async function initializePostgresRepositorySchema(
   await execute(
     sql,
     `CREATE TABLE IF NOT EXISTS "${validatedSchema}"."followees" (
-       followee_id TEXT PRIMARY KEY,
-       follow_json JSONB NOT NULL
+       bot_id TEXT NOT NULL,
+       followee_id TEXT NOT NULL,
+       follow_json JSONB NOT NULL,
+       PRIMARY KEY (bot_id, followee_id)
      )`,
     [],
     prepare,
   );
+  await execute(
+    sql,
+    `CREATE INDEX IF NOT EXISTS "idx_followees_followee_id"
+       ON "${validatedSchema}"."followees" (followee_id)`,
+    [],
+    prepare,
+  );
   await execute(
     sql,
     `CREATE TABLE IF NOT EXISTS "${validatedSchema}"."poll_votes" (
+       bot_id TEXT NOT NULL,
        message_id TEXT NOT NULL,
        voter_id TEXT NOT NULL,
        option TEXT NOT NULL,
-       PRIMARY KEY (message_id, voter_id, option)
+       PRIMARY KEY (bot_id, message_id, voter_id, option)
      )`,
     [],
     prepare,
@@ -223,12 +257,194 @@ export async function initializePostgresRepositorySchema(
   await execute(
     sql,
     `CREATE INDEX IF NOT EXISTS "idx_poll_votes_message_option"
-       ON "${validatedSchema}"."poll_votes" (message_id, option)`,
+       ON "${validatedSchema}"."poll_votes" (bot_id, message_id, option)`,
     [],
     prepare,
   );
 }
 
+const upgradableTables = [
+  "key_pairs",
+  "messages",
+  "followers",
+  "follow_requests",
+  "sent_follows",
+  "followees",
+  "poll_votes",
+] as const;
+
+/**
+ * Upgrades tables created by \@fedify/botkit-postgres 0.4, which had no
+ * `bot_id` column, into the bot-scoped schema.  Existing rows get the
+ * empty-string bot ID; use {@link PostgresRepository.migrate} to assign them
+ * to a bot actor identifier.
+ *
+ * The whole upgrade is sent as a single multi-statement query without
+ * parameters, which PostgreSQL executes over the simple query protocol in
+ * one implicit transaction on one connection, so it is atomic even when
+ * `sql` is a connection pool.
+ */
+async function upgradeLegacySchema(
+  sql: Queryable,
+  schema: string,
+  prepare: boolean,
+): Promise<void> {
+  const rows = await execute<{ readonly table_name: string }>(
+    sql,
+    `SELECT t.table_name
+       FROM information_schema.tables t
+      WHERE t.table_schema = $1
+        AND t.table_name = ANY($2)
+        AND NOT EXISTS (
+          SELECT 1
+            FROM information_schema.columns c
+           WHERE c.table_schema = t.table_schema
+             AND c.table_name = t.table_name
+             AND c.column_name = 'bot_id'
+        )`,
+    [schema, [...upgradableTables]],
+    prepare,
+  );
+  if (rows.length < 1) return;
+  const tables = rows.map((row) => row.table_name);
+  logger.info(
+    "Upgrading legacy tables without a bot_id column: {tables}.",
+    { tables },
+  );
+  // Multiple processes can start against the same legacy schema at once, so
+  // the whole upgrade runs inside one PL/pgSQL block: an advisory lock
+  // serializes it, and every table is re-checked under the lock, so the
+  // process that lost the race finds nothing left to do.  The detection
+  // query above is merely a fast path for already-upgraded schemas.
+  const legacyTable = (table: string) =>
+    `EXISTS (SELECT 1
+        FROM information_schema.tables t
+       WHERE t.table_schema = '${schema}' AND t.table_name = '${table}')
+     AND NOT EXISTS (SELECT 1
+        FROM information_schema.columns c
+       WHERE c.table_schema = '${schema}' AND c.table_name = '${table}'
+         AND c.column_name = 'bot_id')`;
+  const block = `
+    DO $botkit_upgrade$
+    DECLARE
+      upgraded boolean := false;
+    BEGIN
+      PERFORM pg_catalog.pg_advisory_xact_lock(
+        ${schemaUpgradeAdvisoryLockNamespace},
+        pg_catalog.hashtext('${schema}')
+      );
+
+      IF ${legacyTable("follow_requests")} THEN
+        -- The old foreign key referenced followers (follower_id) only; it
+        -- has to go away before the followers primary key changes:
+        ALTER TABLE "${schema}"."follow_requests"
+          DROP CONSTRAINT IF EXISTS "follow_requests_follower_id_fkey";
+      END IF;
+
+      IF ${legacyTable("key_pairs")} THEN
+        ALTER TABLE "${schema}"."key_pairs"
+          ADD COLUMN bot_id TEXT NOT NULL DEFAULT '';
+        ALTER TABLE "${schema}"."key_pairs" ALTER COLUMN bot_id DROP DEFAULT;
+        ALTER TABLE "${schema}"."key_pairs"
+          DROP CONSTRAINT IF EXISTS "key_pairs_pkey";
+        ALTER TABLE "${schema}"."key_pairs" ADD PRIMARY KEY (bot_id, position);
+        upgraded := true;
+      END IF;
+
+      IF ${legacyTable("messages")} THEN
+        ALTER TABLE "${schema}"."messages"
+          ADD COLUMN bot_id TEXT NOT NULL DEFAULT '';
+        ALTER TABLE "${schema}"."messages" ALTER COLUMN bot_id DROP DEFAULT;
+        ALTER TABLE "${schema}"."messages"
+          DROP CONSTRAINT IF EXISTS "messages_pkey";
+        ALTER TABLE "${schema}"."messages" ADD PRIMARY KEY (bot_id, id);
+        DROP INDEX IF EXISTS "${schema}"."idx_messages_published";
+        upgraded := true;
+      END IF;
+
+      IF ${legacyTable("followers")} THEN
+        ALTER TABLE "${schema}"."followers"
+          ADD COLUMN bot_id TEXT NOT NULL DEFAULT '';
+        ALTER TABLE "${schema}"."followers" ALTER COLUMN bot_id DROP DEFAULT;
+        ALTER TABLE "${schema}"."followers"
+          DROP CONSTRAINT IF EXISTS "followers_pkey";
+        ALTER TABLE "${schema}"."followers"
+          ADD PRIMARY KEY (bot_id, follower_id);
+        upgraded := true;
+      END IF;
+
+      IF ${legacyTable("follow_requests")} THEN
+        ALTER TABLE "${schema}"."follow_requests"
+          ADD COLUMN bot_id TEXT NOT NULL DEFAULT '';
+        ALTER TABLE "${schema}"."follow_requests"
+          ALTER COLUMN bot_id DROP DEFAULT;
+        ALTER TABLE "${schema}"."follow_requests"
+          DROP CONSTRAINT IF EXISTS "follow_requests_pkey";
+        ALTER TABLE "${schema}"."follow_requests"
+          ADD PRIMARY KEY (bot_id, follow_request_id);
+        ALTER TABLE "${schema}"."follow_requests"
+          ADD FOREIGN KEY (bot_id, follower_id)
+          REFERENCES "${schema}"."followers" (bot_id, follower_id)
+          ON DELETE CASCADE
+          DEFERRABLE INITIALLY IMMEDIATE;
+        DROP INDEX IF EXISTS "${schema}"."idx_follow_requests_follower";
+        upgraded := true;
+      END IF;
+
+      IF ${legacyTable("sent_follows")} THEN
+        ALTER TABLE "${schema}"."sent_follows"
+          ADD COLUMN bot_id TEXT NOT NULL DEFAULT '';
+        ALTER TABLE "${schema}"."sent_follows"
+          ALTER COLUMN bot_id DROP DEFAULT;
+        ALTER TABLE "${schema}"."sent_follows"
+          DROP CONSTRAINT IF EXISTS "sent_follows_pkey";
+        ALTER TABLE "${schema}"."sent_follows" ADD PRIMARY KEY (bot_id, id);
+        upgraded := true;
+      END IF;
+
+      IF ${legacyTable("followees")} THEN
+        ALTER TABLE "${schema}"."followees"
+          ADD COLUMN bot_id TEXT NOT NULL DEFAULT '';
+        ALTER TABLE "${schema}"."followees" ALTER COLUMN bot_id DROP DEFAULT;
+        ALTER TABLE "${schema}"."followees"
+          DROP CONSTRAINT IF EXISTS "followees_pkey";
+        ALTER TABLE "${schema}"."followees"
+          ADD PRIMARY KEY (bot_id, followee_id);
+        upgraded := true;
+      END IF;
+
+      IF ${legacyTable("poll_votes")} THEN
+        ALTER TABLE "${schema}"."poll_votes"
+          ADD COLUMN bot_id TEXT NOT NULL DEFAULT '';
+        ALTER TABLE "${schema}"."poll_votes" ALTER COLUMN bot_id DROP DEFAULT;
+        ALTER TABLE "${schema}"."poll_votes"
+          DROP CONSTRAINT IF EXISTS "poll_votes_pkey";
+        ALTER TABLE "${schema}"."poll_votes"
+          ADD PRIMARY KEY (bot_id, message_id, voter_id, option);
+        DROP INDEX IF EXISTS "${schema}"."idx_poll_votes_message_option";
+        upgraded := true;
+      END IF;
+
+      IF upgraded THEN
+        -- The marker lets migrate() distinguish rows carried over from
+        -- a legacy schema (bot_id = '') from data legitimately stored under
+        -- an empty-string identifier:
+        CREATE TABLE IF NOT EXISTS "${schema}"."botkit_metadata" (
+          "key" TEXT PRIMARY KEY,
+          value TEXT NOT NULL
+        );
+        INSERT INTO "${schema}"."botkit_metadata" ("key", value)
+        VALUES ('legacy_data', '1')
+        ON CONFLICT ("key") DO NOTHING;
+      END IF;
+    END
+    $botkit_upgrade$
+  `;
+  // DO blocks cannot be prepared:
+  await execute(sql, block, [], false);
+  logger.info("Finished upgrading legacy tables.");
+}
+
 /**
  * A repository for storing bot data using PostgreSQL.
  * @since 0.4.0
@@ -295,19 +511,27 @@ export class PostgresRepository implements Repository, AsyncDisposable {
     }
   }
 
-  async setKeyPairs(keyPairs: CryptoKeyPair[]): Promise<void> {
+  async setKeyPairs(
+    identifier: string,
+    keyPairs: CryptoKeyPair[],
+  ): Promise<void> {
     await this.ensureReady();
     await this.sql.begin(async (sql) => {
-      await this.query(sql, `DELETE FROM ${this.table("key_pairs")}`);
+      await this.query(
+        sql,
+        `DELETE FROM ${this.table("key_pairs")} WHERE bot_id = $1`,
+        [identifier],
+      );
       for (const [position, keyPair] of keyPairs.entries()) {
         const privateJwk = await exportJwk(keyPair.privateKey);
         const publicJwk = await exportJwk(keyPair.publicKey);
         await this.query(
           sql,
           `INSERT INTO ${this.table("key_pairs")}
-             (position, private_key_jwk, public_key_jwk)
-           VALUES ($1, $2::jsonb, $3::jsonb)`,
+             (bot_id, position, private_key_jwk, public_key_jwk)
+           VALUES ($1, $2, $3::jsonb, $4::jsonb)`,
           [
+            identifier,
             position,
             serializeJson(privateJwk),
             serializeJson(publicJwk),
@@ -317,7 +541,7 @@ export class PostgresRepository implements Repository, AsyncDisposable {
     });
   }
 
-  async getKeyPairs(): Promise<CryptoKeyPair[] | undefined> {
+  async getKeyPairs(identifier: string): Promise<CryptoKeyPair[] | undefined> {
     await this.ensureReady();
     const rows = await this.query<{
       readonly private_key_jwk: unknown;
@@ -326,7 +550,9 @@ export class PostgresRepository implements Repository, AsyncDisposable {
       this.sql,
       `SELECT private_key_jwk, public_key_jwk
          FROM ${this.table("key_pairs")}
+        WHERE bot_id = $1
      ORDER BY position ASC`,
+      [identifier],
     );
     if (rows.length < 1) return undefined;
     const keyPairs: CryptoKeyPair[] = [];
@@ -344,13 +570,19 @@ export class PostgresRepository implements Repository, AsyncDisposable {
     return keyPairs;
   }
 
-  async addMessage(id: Uuid, activity: Create | Announce): Promise<void> {
+  async addMessage(
+    identifier: string,
+    id: Uuid,
+    activity: Create | Announce,
+  ): Promise<void> {
     await this.ensureReady();
     await this.query(
       this.sql,
-      `INSERT INTO ${this.table("messages")} (id, activity_json, published)
-       VALUES ($1, $2::jsonb, $3)`,
+      `INSERT INTO ${this.table("messages")}
+         (bot_id, id, activity_json, published)
+       VALUES ($1, $2, $3::jsonb, $4)`,
       [
+        identifier,
         id,
         serializeJson(await activity.toJsonLd({ format: "compact" })),
         activity.published?.epochMilliseconds ?? null,
@@ -359,6 +591,7 @@ export class PostgresRepository implements Repository, AsyncDisposable {
   }
 
   async updateMessage(
+    identifier: string,
     id: Uuid,
     updater: (
       existing: Create | Announce,
@@ -370,9 +603,9 @@ export class PostgresRepository implements Repository, AsyncDisposable {
         sql,
         `SELECT activity_json
            FROM ${this.table("messages")}
-          WHERE id = $1
+          WHERE bot_id = $1 AND id = $2
           FOR UPDATE`,
-        [id],
+        [identifier, id],
       );
       const row = rows[0];
       if (row == null) return false;
@@ -385,10 +618,11 @@ export class PostgresRepository implements Repository, AsyncDisposable {
         `UPDATE ${this.table("messages")}
             SET activity_json = $1::jsonb,
                 published = $2
-          WHERE id = $3`,
+          WHERE bot_id = $3 AND id = $4`,
         [
           serializeJson(await updated.toJsonLd({ format: "compact" })),
           updated.published?.epochMilliseconds ?? null,
+          identifier,
           id,
         ],
       );
@@ -396,27 +630,31 @@ export class PostgresRepository implements Repository, AsyncDisposable {
     });
   }
 
-  async removeMessage(id: Uuid): Promise<Create | Announce | undefined> {
+  async removeMessage(
+    identifier: string,
+    id: Uuid,
+  ): Promise<Create | Announce | undefined> {
     await this.ensureReady();
     const rows = await this.query<{ readonly activity_json: unknown }>(
       this.sql,
       `DELETE FROM ${this.table("messages")}
-        WHERE id = $1
+        WHERE bot_id = $1 AND id = $2
     RETURNING activity_json`,
-      [id],
+      [identifier, id],
     );
     return await parseActivity(rows[0]?.activity_json);
   }
 
   async *getMessages(
+    identifier: string,
     options: RepositoryGetMessagesOptions = {},
   ): AsyncIterable<Create | Announce> {
     await this.ensureReady();
     const { order = "newest", since, until, limit } = options;
-    const parameters: QueryParameter[] = [];
+    const parameters: QueryParameter[] = [identifier];
     let query = `SELECT activity_json
                    FROM ${this.table("messages")}
-                  WHERE TRUE`;
+                  WHERE bot_id = $1`;
     if (since != null) {
       parameters.push(since.epochMilliseconds);
       query += ` AND published >= $${parameters.length}`;
@@ -443,29 +681,38 @@ export class PostgresRepository implements Repository, AsyncDisposable {
     }
   }
 
-  async getMessage(id: Uuid): Promise<Create | Announce | undefined> {
+  async getMessage(
+    identifier: string,
+    id: Uuid,
+  ): Promise<Create | Announce | undefined> {
     await this.ensureReady();
     const rows = await this.query<{ readonly activity_json: unknown }>(
       this.sql,
       `SELECT activity_json
          FROM ${this.table("messages")}
-        WHERE id = $1`,
-      [id],
+        WHERE bot_id = $1 AND id = $2`,
+      [identifier, id],
     );
     return await parseActivity(rows[0]?.activity_json);
   }
 
-  async countMessages(): Promise<number> {
+  async countMessages(identifier: string): Promise<number> {
     await this.ensureReady();
     const rows = await this.query<{ readonly count: number }>(
       this.sql,
       `SELECT COUNT(*)::integer AS count
-         FROM ${this.table("messages")}`,
+         FROM ${this.table("messages")}
+        WHERE bot_id = $1`,
+      [identifier],
     );
     return rows[0]?.count ?? 0;
   }
 
-  async addFollower(followId: URL, follower: Actor): Promise<void> {
+  async addFollower(
+    identifier: string,
+    followId: URL,
+    follower: Actor,
+  ): Promise<void> {
     await this.ensureReady();
     if (follower.id == null) {
       throw new TypeError("The follower ID is missing.");
@@ -473,97 +720,101 @@ export class PostgresRepository implements Repository, AsyncDisposable {
     const followerId = follower.id;
     const followerJson = await follower.toJsonLd({ format: "compact" });
     await this.sql.begin(async (sql) => {
-      await this.lockFollowRequest(sql, followId);
+      await this.lockFollowRequest(sql, identifier, followId);
       const rows = await this.query<{ readonly follower_id: string }>(
         sql,
         `SELECT follower_id
            FROM ${this.table("follow_requests")}
-          WHERE follow_request_id = $1
+          WHERE bot_id = $1 AND follow_request_id = $2
           FOR UPDATE`,
-        [followId.href],
+        [identifier, followId.href],
       );
       const previousFollowerId = rows[0]?.follower_id;
-      await this.lockFollowers(sql, [
+      await this.lockFollowers(sql, identifier, [
         followerId.href,
         ...(previousFollowerId == null ? [] : [previousFollowerId]),
       ]);
       await this.query(
         sql,
-        `INSERT INTO ${this.table("followers")} (follower_id, actor_json)
-         VALUES ($1, $2::jsonb)
-         ON CONFLICT (follower_id)
+        `INSERT INTO ${this.table("followers")}
+           (bot_id, follower_id, actor_json)
+         VALUES ($1, $2, $3::jsonb)
+         ON CONFLICT (bot_id, follower_id)
          DO UPDATE SET actor_json = EXCLUDED.actor_json`,
-        [followerId.href, serializeJson(followerJson)],
+        [identifier, followerId.href, serializeJson(followerJson)],
       );
       await this.query(
         sql,
-        `INSERT INTO ${
-          this.table("follow_requests")
-        } (follow_request_id, follower_id)
-         VALUES ($1, $2)
-         ON CONFLICT (follow_request_id)
+        `INSERT INTO ${this.table("follow_requests")}
+           (bot_id, follow_request_id, follower_id)
+         VALUES ($1, $2, $3)
+         ON CONFLICT (bot_id, follow_request_id)
          DO UPDATE SET follower_id = EXCLUDED.follower_id`,
-        [followId.href, followerId.href],
+        [identifier, followId.href, followerId.href],
       );
       if (
         previousFollowerId != null && previousFollowerId !== followerId.href
       ) {
-        await this.cleanupFollower(sql, previousFollowerId);
+        await this.cleanupFollower(sql, identifier, previousFollowerId);
       }
     });
   }
 
   async removeFollower(
+    identifier: string,
     followId: URL,
     followerId: URL,
   ): Promise<Actor | undefined> {
     await this.ensureReady();
     return await this.sql.begin(async (sql) => {
-      await this.lockFollowRequest(sql, followId);
+      await this.lockFollowRequest(sql, identifier, followId);
       const rows = await this.query<{ readonly actor_json: unknown }>(
         sql,
         `SELECT f.actor_json
            FROM ${this.table("follow_requests")} AS fr
            JOIN ${this.table("followers")} AS f
-             ON f.follower_id = fr.follower_id
-          WHERE fr.follow_request_id = $1
-            AND fr.follower_id = $2
+             ON f.bot_id = fr.bot_id AND f.follower_id = fr.follower_id
+          WHERE fr.bot_id = $1
+            AND fr.follow_request_id = $2
+            AND fr.follower_id = $3
           FOR UPDATE`,
-        [followId.href, followerId.href],
+        [identifier, followId.href, followerId.href],
       );
       const row = rows[0];
       if (row == null) return undefined;
       await this.query(
         sql,
         `DELETE FROM ${this.table("follow_requests")}
-          WHERE follow_request_id = $1`,
-        [followId.href],
+          WHERE bot_id = $1 AND follow_request_id = $2`,
+        [identifier, followId.href],
       );
-      await this.cleanupFollower(sql, followerId.href);
+      await this.cleanupFollower(sql, identifier, followerId.href);
       return await parseActor(row.actor_json);
     });
   }
 
-  async hasFollower(followerId: URL): Promise<boolean> {
+  async hasFollower(identifier: string, followerId: URL): Promise<boolean> {
     await this.ensureReady();
     const rows = await this.query<{ readonly exists: number }>(
       this.sql,
       `SELECT 1 AS exists
          FROM ${this.table("followers")}
-        WHERE follower_id = $1`,
-      [followerId.href],
+        WHERE bot_id = $1 AND follower_id = $2`,
+      [identifier, followerId.href],
     );
     return rows.length > 0;
   }
 
   async *getFollowers(
+    identifier: string,
     options: RepositoryGetFollowersOptions = {},
   ): AsyncIterable<Actor> {
     await this.ensureReady();
     const { offset = 0, limit } = options;
-    const parameters: QueryParameter[] = [];
+    const parameters: QueryParameter[] = [identifier];
     let query = `SELECT actor_json
                    FROM ${this.table("followers")}
+                  WHERE bot_id = $1
                ORDER BY follower_id ASC`;
     if (limit != null) {
       parameters.push(limit, offset);
@@ -583,116 +834,166 @@ export class PostgresRepository implements Repository, AsyncDisposable {
     }
   }
 
-  async countFollowers(): Promise<number> {
+  async countFollowers(identifier: string): Promise<number> {
     await this.ensureReady();
     const rows = await this.query<{ readonly count: number }>(
       this.sql,
       `SELECT COUNT(*)::integer AS count
-         FROM ${this.table("followers")}`,
+         FROM ${this.table("followers")}
+        WHERE bot_id = $1`,
+      [identifier],
     );
     return rows[0]?.count ?? 0;
   }
 
-  async addSentFollow(id: Uuid, follow: Follow): Promise<void> {
+  async addSentFollow(
+    identifier: string,
+    id: Uuid,
+    follow: Follow,
+  ): Promise<void> {
     await this.ensureReady();
     await this.query(
       this.sql,
-      `INSERT INTO ${this.table("sent_follows")} (id, follow_json)
-       VALUES ($1, $2::jsonb)
-       ON CONFLICT (id)
+      `INSERT INTO ${this.table("sent_follows")} (bot_id, id, follow_json)
+       VALUES ($1, $2, $3::jsonb)
+       ON CONFLICT (bot_id, id)
        DO UPDATE SET follow_json = EXCLUDED.follow_json`,
-      [id, serializeJson(await follow.toJsonLd({ format: "compact" }))],
+      [
+        identifier,
+        id,
+        serializeJson(await follow.toJsonLd({ format: "compact" })),
+      ],
     );
   }
 
-  async removeSentFollow(id: Uuid): Promise<Follow | undefined> {
+  async removeSentFollow(
+    identifier: string,
+    id: Uuid,
+  ): Promise<Follow | undefined> {
     await this.ensureReady();
     const rows = await this.query<{ readonly follow_json: unknown }>(
       this.sql,
       `DELETE FROM ${this.table("sent_follows")}
-        WHERE id = $1
+        WHERE bot_id = $1 AND id = $2
     RETURNING follow_json`,
-      [id],
+      [identifier, id],
     );
     return await parseFollow(rows[0]?.follow_json);
   }
 
-  async getSentFollow(id: Uuid): Promise<Follow | undefined> {
+  async getSentFollow(
+    identifier: string,
+    id: Uuid,
+  ): Promise<Follow | undefined> {
     await this.ensureReady();
     const rows = await this.query<{ readonly follow_json: unknown }>(
       this.sql,
       `SELECT follow_json
          FROM ${this.table("sent_follows")}
-        WHERE id = $1`,
-      [id],
+        WHERE bot_id = $1 AND id = $2`,
+      [identifier, id],
     );
     return await parseFollow(rows[0]?.follow_json);
   }
 
-  async addFollowee(followeeId: URL, follow: Follow): Promise<void> {
+  async addFollowee(
+    identifier: string,
+    followeeId: URL,
+    follow: Follow,
+  ): Promise<void> {
     await this.ensureReady();
     await this.query(
       this.sql,
-      `INSERT INTO ${this.table("followees")} (followee_id, follow_json)
-       VALUES ($1, $2::jsonb)
-       ON CONFLICT (followee_id)
+      `INSERT INTO ${this.table("followees")}
+         (bot_id, followee_id, follow_json)
+       VALUES ($1, $2, $3::jsonb)
+       ON CONFLICT (bot_id, followee_id)
        DO UPDATE SET follow_json = EXCLUDED.follow_json`,
       [
+        identifier,
         followeeId.href,
         serializeJson(await follow.toJsonLd({ format: "compact" })),
       ],
     );
   }
 
-  async removeFollowee(followeeId: URL): Promise<Follow | undefined> {
+  async removeFollowee(
+    identifier: string,
+    followeeId: URL,
+  ): Promise<Follow | undefined> {
     await this.ensureReady();
     const rows = await this.query<{ readonly follow_json: unknown }>(
       this.sql,
       `DELETE FROM ${this.table("followees")}
-        WHERE followee_id = $1
+        WHERE bot_id = $1 AND followee_id = $2
     RETURNING follow_json`,
-      [followeeId.href],
+      [identifier, followeeId.href],
     );
     return await parseFollow(rows[0]?.follow_json);
   }
 
-  async getFollowee(followeeId: URL): Promise<Follow | undefined> {
+  async getFollowee(
+    identifier: string,
+    followeeId: URL,
+  ): Promise<Follow | undefined> {
     await this.ensureReady();
     const rows = await this.query<{ readonly follow_json: unknown }>(
       this.sql,
       `SELECT follow_json
          FROM ${this.table("followees")}
-        WHERE followee_id = $1`,
-      [followeeId.href],
+        WHERE bot_id = $1 AND followee_id = $2`,
+      [identifier, followeeId.href],
     );
     return await parseFollow(rows[0]?.follow_json);
   }
 
-  async vote(messageId: Uuid, voterId: URL, option: string): Promise<void> {
+  async *findFollowedBots(followeeId: URL): AsyncIterable<string> {
+    await this.ensureReady();
+    const rows = await this.query<{ readonly bot_id: string }>(
+      this.sql,
+      `SELECT bot_id
+         FROM ${this.table("followees")}
+        WHERE followee_id = $1
+     ORDER BY bot_id ASC`,
+      [followeeId.href],
+    );
+    for (const row of rows) yield row.bot_id;
+  }
+
+  async vote(
+    identifier: string,
+    messageId: Uuid,
+    voterId: URL,
+    option: string,
+  ): Promise<void> {
     await this.ensureReady();
     await this.query(
       this.sql,
-      `INSERT INTO ${this.table("poll_votes")} (message_id, voter_id, option)
-       VALUES ($1, $2, $3)
-       ON CONFLICT (message_id, voter_id, option)
+      `INSERT INTO ${this.table("poll_votes")}
+         (bot_id, message_id, voter_id, option)
+       VALUES ($1, $2, $3, $4)
+       ON CONFLICT (bot_id, message_id, voter_id, option)
        DO NOTHING`,
-      [messageId, voterId.href, option],
+      [identifier, messageId, voterId.href, option],
     );
   }
 
-  async countVoters(messageId: Uuid): Promise<number> {
+  async countVoters(identifier: string, messageId: Uuid): Promise<number> {
     await this.ensureReady();
     const rows = await this.query<{ readonly count: number }>(
       this.sql,
       `SELECT COUNT(DISTINCT voter_id)::integer AS count
          FROM ${this.table("poll_votes")}
-        WHERE message_id = $1`,
-      [messageId],
+        WHERE bot_id = $1 AND message_id = $2`,
+      [identifier, messageId],
     );
     return rows[0]?.count ?? 0;
   }
 
-  async countVotes(messageId: Uuid): Promise<Readonly<Record<string, number>>> {
+  async countVotes(
+    identifier: string,
+    messageId: Uuid,
+  ): Promise<Readonly<Record<string, number>>> {
     await this.ensureReady();
     const rows = await this.query<{
       readonly option: string;
@@ -701,10 +1002,10 @@ export class PostgresRepository implements Repository, AsyncDisposable {
       this.sql,
       `SELECT option, COUNT(*)::integer AS count
          FROM ${this.table("poll_votes")}
-        WHERE message_id = $1
+        WHERE bot_id = $1 AND message_id = $2
      GROUP BY option
      ORDER BY option ASC`,
-      [messageId],
+      [identifier, messageId],
     );
     const result: Record<string, number> = {};
     for (const row of rows) {
@@ -713,12 +1014,61 @@ export class PostgresRepository implements Repository, AsyncDisposable {
     return result;
   }
 
+  /**
+   * Migrates data stored by \@fedify/botkit-postgres 0.4, which was not
+   * scoped by bot actor identifiers, so that it belongs to the given
+   * identifier.  Rows carried over from a legacy schema have the
+   * empty-string bot ID; this method assigns them to the identifier in
+   * a single transaction.  It only acts when the schema was actually
+   * upgraded from a legacy layout, so data legitimately stored under an
+   * empty-string identifier is never touched, and calling it again is
+   * a no-op.
+   * @param identifier The identifier of the bot actor that adopts the legacy
+   *                   data.
+   * @since 0.5.0
+   */
+  async migrate(identifier: string): Promise<void> {
+    await this.ensureReady();
+    await this.sql.begin(async (sql) => {
+      const rows = await this.query<{ readonly value: string }>(
+        sql,
+        `SELECT value FROM ${this.table("botkit_metadata")}
+          WHERE "key" = 'legacy_data'
+            FOR UPDATE`,
+      );
+      if (rows.length < 1) return;
+      // The followers and follow_requests rows move in tandem, which
+      // temporarily breaks the foreign key between them; defer the check to
+      // the commit:
+      await execute(sql, "SET CONSTRAINTS ALL DEFERRED", [], false);
+      for (const table of upgradableTables) {
+        await this.query(
+          sql,
+          `UPDATE "${this.schema}"."${table}"
+              SET bot_id = $1
+            WHERE bot_id = ''`,
+          [identifier],
+        );
+      }
+      await this.query(
+        sql,
+        `DELETE FROM ${this.table("botkit_metadata")}
+          WHERE "key" = 'legacy_data'`,
+      );
+    });
+  }
+
+  forIdentifier(identifier: string): ActorScopedRepository {
+    return new ActorScopedRepository(this, identifier);
+  }
+
   private table(name: string): string {
     return `"${this.schema}"."${name}"`;
   }
 
   private async lockFollowRequest(
     sql: Queryable,
+    identifier: string,
     followId: URL,
   ): Promise<void> {
     await this.query(
@@ -726,13 +1076,14 @@ export class PostgresRepository implements Repository, AsyncDisposable {
       `SELECT pg_catalog.pg_advisory_xact_lock($1, pg_catalog.hashtext($2))`,
       [
         followRequestAdvisoryLockNamespace,
-        `${this.schema}:${followId.href}`,
+        `${this.schema}:${identifier}:${followId.href}`,
       ],
     );
   }
 
   private async lockFollower(
     sql: Queryable,
+    identifier: string,
     followerId: string,
   ): Promise<void> {
     await this.query(
@@ -740,36 +1091,40 @@ export class PostgresRepository implements Repository, AsyncDisposable {
       `SELECT pg_catalog.pg_advisory_xact_lock($1, pg_catalog.hashtext($2))`,
       [
         followerAdvisoryLockNamespace,
-        `${this.schema}:${followerId}`,
+        `${this.schema}:${identifier}:${followerId}`,
       ],
     );
   }
 
   private async lockFollowers(
     sql: Queryable,
+    identifier: string,
     followerIds: readonly string[],
   ): Promise<void> {
     const uniqueFollowerIds = [...new Set(followerIds)].sort();
     for (const followerId of uniqueFollowerIds) {
-      await this.lockFollower(sql, followerId);
+      await this.lockFollower(sql, identifier, followerId);
     }
   }
 
   private async cleanupFollower(
     sql: Queryable,
+    identifier: string,
     followerId: string,
   ): Promise<void> {
-    await this.lockFollower(sql, followerId);
+    await this.lockFollower(sql, identifier, followerId);
     await this.query(
       sql,
       `DELETE FROM ${this.table("followers")}
-        WHERE follower_id = $1
+        WHERE bot_id = $1
+          AND follower_id = $2
           AND NOT EXISTS (
             SELECT 1
               FROM ${this.table("follow_requests")}
-             WHERE follower_id = $1
+             WHERE bot_id = $1
+               AND follower_id = $2
           )`,
-      [followerId],
+      [identifier, followerId],
     );
   }
 
diff --git a/packages/botkit-sqlite/package.json b/packages/botkit-sqlite/package.json
index b47fe67..cdb7f34 100644
--- a/packages/botkit-sqlite/package.json
+++ b/packages/botkit-sqlite/package.json
@@ -43,7 +43,7 @@
     "README.md"
   ],
   "peerDependencies": {
-    "@fedify/botkit": "workspace:"
+    "@fedify/botkit": "workspace:^"
   },
   "dependencies": {
     "@fedify/fedify": "catalog:",
diff --git a/packages/botkit-sqlite/src/mod.test.ts b/packages/botkit-sqlite/src/mod.test.ts
index c18b5e6..8d5ca53 100644
--- a/packages/botkit-sqlite/src/mod.test.ts
+++ b/packages/botkit-sqlite/src/mod.test.ts
@@ -18,11 +18,12 @@ import {
   type SqliteRepositoryOptions,
 } from "@fedify/botkit-sqlite";
 import { importJwk } from "@fedify/fedify/sig";
-import { Create, Note, Person, PUBLIC_COLLECTION } from "@fedify/vocab";
+import { Create, Follow, Note, Person, PUBLIC_COLLECTION } from "@fedify/vocab";
 import assert from "node:assert";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
 import { describe, test } from "node:test";
 
 if (!("Temporal" in globalThis)) {
@@ -73,9 +74,9 @@ describe("SqliteRepository", () => {
   test("key pairs", async () => {
     const repo = createSqliteRepository();
     try {
-      assert.deepStrictEqual(await repo.getKeyPairs(), undefined);
-      await repo.setKeyPairs(keyPairs);
-      assert.deepStrictEqual(await repo.getKeyPairs(), keyPairs);
+      assert.deepStrictEqual(await repo.getKeyPairs("bot"), undefined);
+      await repo.setKeyPairs("bot", keyPairs);
+      assert.deepStrictEqual(await repo.getKeyPairs("bot"), keyPairs);
     } finally {
       repo.close();
     }
@@ -84,9 +85,9 @@ describe("SqliteRepository", () => {
   test("messages basic operations", async () => {
     const repo = createSqliteRepository();
     try {
-      assert.deepStrictEqual(await repo.countMessages(), 0);
+      assert.deepStrictEqual(await repo.countMessages("bot"), 0);
       assert.deepStrictEqual(
-        await repo.getMessage("01941f29-7c00-7fe8-ab0a-7b593990a3c0"),
+        await repo.getMessage("bot", "01941f29-7c00-7fe8-ab0a-7b593990a3c0"),
         undefined,
       );
 
@@ -110,10 +111,15 @@ describe("SqliteRepository", () => {
         published: Temporal.Instant.from("2025-01-01T00:00:00Z"),
       });
 
-      await repo.addMessage("01941f29-7c00-7fe8-ab0a-7b593990a3c0", message);
-      assert.deepStrictEqual(await repo.countMessages(), 1);
+      await repo.addMessage(
+        "bot",
+        "01941f29-7c00-7fe8-ab0a-7b593990a3c0",
+        message,
+      );
+      assert.deepStrictEqual(await repo.countMessages("bot"), 1);
 
       const retrieved = await repo.getMessage(
+        "bot",
         "01941f29-7c00-7fe8-ab0a-7b593990a3c0",
       );
       assert.deepStrictEqual(
@@ -122,13 +128,14 @@ describe("SqliteRepository", () => {
       );
 
       const removed = await repo.removeMessage(
+        "bot",
         "01941f29-7c00-7fe8-ab0a-7b593990a3c0",
       );
       assert.deepStrictEqual(
         await removed?.toJsonLd(),
         await message.toJsonLd(),
       );
-      assert.deepStrictEqual(await repo.countMessages(), 0);
+      assert.deepStrictEqual(await repo.countMessages("bot"), 0);
     } finally {
       repo.close();
     }
@@ -145,23 +152,29 @@ describe("SqliteRepository", () => {
         "https://example.com/ap/follow/be2da56a-0ea3-4a6a-9dff-2a1837be67e0",
       );
 
-      assert.deepStrictEqual(await repo.countFollowers(), 0);
-      assert.deepStrictEqual(await repo.hasFollower(follower.id!), false);
+      assert.deepStrictEqual(await repo.countFollowers("bot"), 0);
+      assert.deepStrictEqual(
+        await repo.hasFollower("bot", follower.id!),
+        false,
+      );
 
-      await repo.addFollower(followRequestId, follower);
-      assert.deepStrictEqual(await repo.countFollowers(), 1);
-      assert.ok(await repo.hasFollower(follower.id!));
+      await repo.addFollower("bot", followRequestId, follower);
+      assert.deepStrictEqual(await repo.countFollowers("bot"), 1);
+      assert.ok(await repo.hasFollower("bot", follower.id!));
 
-      const followers = await Array.fromAsync(repo.getFollowers());
+      const followers = await Array.fromAsync(repo.getFollowers("bot"));
       assert.deepStrictEqual(followers.length, 1);
       assert.deepStrictEqual(
         await followers[0].toJsonLd(),
         await follower.toJsonLd(),
       );
 
-      await repo.removeFollower(followRequestId, follower.id!);
-      assert.deepStrictEqual(await repo.countFollowers(), 0);
-      assert.deepStrictEqual(await repo.hasFollower(follower.id!), false);
+      await repo.removeFollower("bot", followRequestId, follower.id!);
+      assert.deepStrictEqual(await repo.countFollowers("bot"), 0);
+      assert.deepStrictEqual(
+        await repo.hasFollower("bot", follower.id!),
+        false,
+      );
     } finally {
       repo.close();
     }
@@ -175,34 +188,34 @@ describe("SqliteRepository", () => {
       const voter2 = new URL("https://example.com/ap/actor/bob");
 
       // Initially, no votes exist
-      assert.deepStrictEqual(await repo.countVoters(messageId), 0);
-      assert.deepStrictEqual(await repo.countVotes(messageId), {});
+      assert.deepStrictEqual(await repo.countVoters("bot", messageId), 0);
+      assert.deepStrictEqual(await repo.countVotes("bot", messageId), {});
 
       // Single voter, single option
-      await repo.vote(messageId, voter1, "option1");
-      assert.deepStrictEqual(await repo.countVoters(messageId), 1);
-      assert.deepStrictEqual(await repo.countVotes(messageId), {
+      await repo.vote("bot", messageId, voter1, "option1");
+      assert.deepStrictEqual(await repo.countVoters("bot", messageId), 1);
+      assert.deepStrictEqual(await repo.countVotes("bot", messageId), {
         "option1": 1,
       });
 
       // Same voter votes for same option again (should be ignored)
-      await repo.vote(messageId, voter1, "option1");
-      assert.deepStrictEqual(await repo.countVoters(messageId), 1);
-      assert.deepStrictEqual(await repo.countVotes(messageId), {
+      await repo.vote("bot", messageId, voter1, "option1");
+      assert.deepStrictEqual(await repo.countVoters("bot", messageId), 1);
+      assert.deepStrictEqual(await repo.countVotes("bot", messageId), {
         "option1": 1,
       });
 
       // Different voter votes for same option
-      await repo.vote(messageId, voter2, "option1");
-      assert.deepStrictEqual(await repo.countVoters(messageId), 2);
-      assert.deepStrictEqual(await repo.countVotes(messageId), {
+      await repo.vote("bot", messageId, voter2, "option1");
+      assert.deepStrictEqual(await repo.countVoters("bot", messageId), 2);
+      assert.deepStrictEqual(await repo.countVotes("bot", messageId), {
         "option1": 2,
       });
 
       // Same voter votes for different option (multiple choice)
-      await repo.vote(messageId, voter1, "option2");
-      assert.deepStrictEqual(await repo.countVoters(messageId), 2);
-      assert.deepStrictEqual(await repo.countVotes(messageId), {
+      await repo.vote("bot", messageId, voter1, "option2");
+      assert.deepStrictEqual(await repo.countVoters("bot", messageId), 2);
+      assert.deepStrictEqual(await repo.countVotes("bot", messageId), {
         "option1": 2,
         "option2": 1,
       });
@@ -218,7 +231,7 @@ describe("SqliteRepository", () => {
     try {
       // Create and populate first repository
       const repo1 = createSqliteRepository({ path: dbPath });
-      await repo1.setKeyPairs(keyPairs);
+      await repo1.setKeyPairs("bot", keyPairs);
 
       const message = new Create({
         id: new URL(
@@ -240,17 +253,24 @@ describe("SqliteRepository", () => {
         published: Temporal.Instant.from("2025-01-01T00:00:00Z"),
       });
 
-      await repo1.addMessage("01941f29-7c00-7fe8-ab0a-7b593990a3c0", message);
+      await repo1.addMessage(
+        "bot",
+        "01941f29-7c00-7fe8-ab0a-7b593990a3c0",
+        message,
+      );
       repo1.close();
 
       // Open the same database file with a new repository instance
       const repo2 = createSqliteRepository({ path: dbPath });
       try {
         // Verify data persists
-        assert.deepStrictEqual(await repo2.getKeyPairs(), keyPairs);
-        assert.deepStrictEqual(await repo2.countMessages(), 1);
+        assert.deepStrictEqual(await repo2.getKeyPairs("bot"), keyPairs);
+        assert.deepStrictEqual(await repo2.countMessages("bot"), 1);
         assert.deepStrictEqual(
-          await (await repo2.getMessage("01941f29-7c00-7fe8-ab0a-7b593990a3c0"))
+          await (await repo2.getMessage(
+            "bot",
+            "01941f29-7c00-7fe8-ab0a-7b593990a3c0",
+          ))
             ?.toJsonLd(),
           await message.toJsonLd(),
         );
@@ -263,3 +283,378 @@ describe("SqliteRepository", () => {
     }
   });
 });
+
+describe("SqliteRepository multitenancy", () => {
+  test("isolates data by bot identifier", async () => {
+    const repo = createSqliteRepository();
+    try {
+      const messageId = "01941f29-7c00-7fe8-ab0a-7b593990a3c0" as const;
+      const message = new Create({
+        id: new URL(
+          `https://example.com/ap/actor/botA/create/${messageId}`,
+        ),
+        actor: new URL("https://example.com/ap/actor/botA"),
+        object: new Note({
+          id: new URL(`https://example.com/ap/actor/botA/note/${messageId}`),
+          content: "Hello, world!",
+        }),
+      });
+      await repo.addMessage("botA", messageId, message);
+      assert.deepStrictEqual(
+        await repo.getMessage("botB", messageId),
+        undefined,
+      );
+      assert.deepStrictEqual(await repo.countMessages("botB"), 0);
+      assert.deepStrictEqual(await repo.countMessages("botA"), 1);
+      assert.deepStrictEqual(
+        await repo.removeMessage("botB", messageId),
+        undefined,
+      );
+      assert.deepStrictEqual(await repo.countMessages("botA"), 1);
+
+      const follower = new Person({
+        id: new URL("https://example.com/ap/actor/john"),
+        preferredUsername: "john",
+      });
+      const followId = new URL(
+        "https://example.com/ap/follow/be2da56a-0ea3-4a6a-9dff-2a1837be67e0",
+      );
+      await repo.addFollower("botA", followId, follower);
+      assert.deepStrictEqual(
+        await repo.hasFollower("botB", follower.id!),
+        false,
+      );
+      assert.ok(await repo.hasFollower("botA", follower.id!));
+      assert.deepStrictEqual(
+        await repo.removeFollower("botB", followId, follower.id!),
+        undefined,
+      );
+      assert.ok(await repo.hasFollower("botA", follower.id!));
+
+      await repo.setKeyPairs("botA", keyPairs);
+      assert.deepStrictEqual(await repo.getKeyPairs("botB"), undefined);
+      assert.deepStrictEqual(await repo.getKeyPairs("botA"), keyPairs);
+
+      await repo.vote("botA", messageId, follower.id!, "option1");
+      assert.deepStrictEqual(await repo.countVoters("botB", messageId), 0);
+      assert.deepStrictEqual(await repo.countVoters("botA", messageId), 1);
+    } finally {
+      repo.close();
+    }
+  });
+
+  test("findFollowedBots()", async () => {
+    const repo = createSqliteRepository();
+    try {
+      const followeeId = new URL("https://example.com/ap/actor/john");
+      const followA = new Follow({
+        id: new URL(
+          "https://example.com/ap/actor/botA/follow/03a395a2-353a-4894-afdb-2cab31a7b004",
+        ),
+        actor: new URL("https://example.com/ap/actor/botA"),
+        object: followeeId,
+      });
+      const followB = new Follow({
+        id: new URL(
+          "https://example.com/ap/actor/botB/follow/e35ff5d8-ede9-4f5e-9b83-4bfcd4c9a69c",
+        ),
+        actor: new URL("https://example.com/ap/actor/botB"),
+        object: followeeId,
+      });
+      assert.deepStrictEqual(
+        await Array.fromAsync(repo.findFollowedBots(followeeId)),
+        [],
+      );
+      await repo.addFollowee("botA", followeeId, followA);
+      await repo.addFollowee("botB", followeeId, followB);
+      assert.deepStrictEqual(
+        await Array.fromAsync(repo.findFollowedBots(followeeId)),
+        ["botA", "botB"],
+      );
+      await repo.removeFollowee("botA", followeeId);
+      assert.deepStrictEqual(
+        await Array.fromAsync(repo.findFollowedBots(followeeId)),
+        ["botB"],
+      );
+    } finally {
+      repo.close();
+    }
+  });
+});
+
+describe("SqliteRepository legacy schema migration", () => {
+  function createLegacyDatabase(path: string): void {
+    // The schema used by @fedify/botkit-sqlite 0.4 and earlier:
+    const db = new DatabaseSync(path);
+    db.exec("PRAGMA foreign_keys = ON;");
+    db.exec(`
+      CREATE TABLE key_pairs (
+        id INTEGER PRIMARY KEY,
+        private_key_jwk TEXT NOT NULL,
+        public_key_jwk TEXT NOT NULL
+      )
+    `);
+    db.exec(`
+      CREATE TABLE messages (
+        id TEXT PRIMARY KEY,
+        activity_json TEXT NOT NULL,
+        published INTEGER
+      )
+    `);
+    db.exec(
+      "CREATE INDEX idx_messages_published ON messages(published)",
+    );
+    db.exec(`
+      CREATE TABLE followers (
+        follower_id TEXT PRIMARY KEY,
+        actor_json TEXT NOT NULL
+      )
+    `);
+    db.exec(`
+      CREATE TABLE follow_requests (
+        follow_request_id TEXT PRIMARY KEY,
+        follower_id TEXT NOT NULL,
+        FOREIGN KEY (follower_id) REFERENCES followers(follower_id)
+      )
+    `);
+    db.exec(`
+      CREATE TABLE sent_follows (
+        id TEXT PRIMARY KEY,
+        follow_json TEXT NOT NULL
+      )
+    `);
+    db.exec(`
+      CREATE TABLE followees (
+        followee_id TEXT PRIMARY KEY,
+        follow_json TEXT NOT NULL
+      )
+    `);
+    db.exec(`
+      CREATE TABLE poll_votes (
+        message_id TEXT NOT NULL,
+        voter_id TEXT NOT NULL,
+        option TEXT NOT NULL,
+        PRIMARY KEY (message_id, voter_id, option)
+      )
+    `);
+    db.close();
+  }
+
+  async function seedLegacyDatabase(path: string): Promise<{
+    messageId: string;
+    followerId: string;
+    followRequestId: string;
+    followeeId: string;
+    sentFollowId: string;
+  }> {
+    const db = new DatabaseSync(path);
+    const messageId = "01941f29-7c00-7fe8-ab0a-7b593990a3c0";
+    const message = new Create({
+      id: new URL(`https://example.com/ap/create/${messageId}`),
+      actor: new URL("https://example.com/ap/actor/bot"),
+      object: new Note({
+        id: new URL(`https://example.com/ap/note/${messageId}`),
+        content: "Hello, world!",
+        published: Temporal.Instant.from("2025-01-01T00:00:00Z"),
+      }),
+      published: Temporal.Instant.from("2025-01-01T00:00:00Z"),
+    });
+    db.prepare(
+      "INSERT INTO messages (id, activity_json, published) VALUES (?, ?, ?)",
+    ).run(
+      messageId,
+      JSON.stringify(await message.toJsonLd({ format: "compact" })),
+      Temporal.Instant.from("2025-01-01T00:00:00Z").epochMilliseconds,
+    );
+
+    const follower = new Person({
+      id: new URL("https://example.com/ap/actor/john"),
+      preferredUsername: "john",
+    });
+    const followRequestId =
+      "https://example.com/ap/follow/be2da56a-0ea3-4a6a-9dff-2a1837be67e0";
+    db.prepare(
+      "INSERT INTO followers (follower_id, actor_json) VALUES (?, ?)",
+    ).run(
+      follower.id!.href,
+      JSON.stringify(await follower.toJsonLd({ format: "compact" })),
+    );
+    db.prepare(
+      "INSERT INTO follow_requests (follow_request_id, follower_id) VALUES (?, ?)",
+    ).run(followRequestId, follower.id!.href);
+
+    const followeeId = "https://example.com/ap/actor/jane";
+    const followeeFollow = new Follow({
+      id: new URL(
+        "https://example.com/ap/follow/03a395a2-353a-4894-afdb-2cab31a7b004",
+      ),
+      actor: new URL("https://example.com/ap/actor/bot"),
+      object: new URL(followeeId),
+    });
+    db.prepare(
+      "INSERT INTO followees (followee_id, follow_json) VALUES (?, ?)",
+    ).run(
+      followeeId,
+      JSON.stringify(await followeeFollow.toJsonLd({ format: "compact" })),
+    );
+
+    const sentFollowId = "e35ff5d8-ede9-4f5e-9b83-4bfcd4c9a69c";
+    const sentFollow = new Follow({
+      id: new URL(`https://example.com/ap/follow/${sentFollowId}`),
+      actor: new URL("https://example.com/ap/actor/bot"),
+      object: new URL("https://example.com/ap/actor/joe"),
+    });
+    db.prepare(
+      "INSERT INTO sent_follows (id, follow_json) VALUES (?, ?)",
+    ).run(
+      sentFollowId,
+      JSON.stringify(await sentFollow.toJsonLd({ format: "compact" })),
+    );
+
+    db.prepare(
+      "INSERT INTO poll_votes (message_id, voter_id, option) VALUES (?, ?, ?)",
+    ).run(messageId, "https://example.com/ap/actor/alice", "option1");
+
+    db.close();
+    return {
+      messageId,
+      followerId: follower.id!.href,
+      followRequestId,
+      followeeId,
+      sentFollowId,
+    };
+  }
+
+  test("rebuilds a legacy database and adopts its data", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "botkit-sqlite-test-"));
+    try {
+      const path = join(dir, "legacy.db");
+      createLegacyDatabase(path);
+      const seed = await seedLegacyDatabase(path);
+
+      // Opening a legacy database rebuilds the schema with bot_id columns;
+      // existing rows get the empty-string bot ID:
+      const repo = new SqliteRepository({ path });
+      try {
+        assert.deepStrictEqual(await repo.countMessages("bot"), 0);
+
+        // migrate() assigns the legacy rows to the given identifier:
+        await repo.migrate("bot");
+        assert.deepStrictEqual(await repo.countMessages("bot"), 1);
+        assert.ok(
+          await repo.getMessage(
+            "bot",
+            seed
+              .messageId as `${string}-${string}-${string}-${string}-${string}`,
+          ) != null,
+        );
+        assert.ok(await repo.hasFollower("bot", new URL(seed.followerId)));
+        assert.ok(
+          await repo.getFollowee("bot", new URL(seed.followeeId)) != null,
+        );
+        assert.ok(
+          await repo.getSentFollow(
+            "bot",
+            seed
+              .sentFollowId as `${string}-${string}-${string}-${string}-${string}`,
+          ) != null,
+        );
+        assert.deepStrictEqual(
+          await repo.countVoters(
+            "bot",
+            seed
+              .messageId as `${string}-${string}-${string}-${string}-${string}`,
+          ),
+          1,
+        );
+        assert.deepStrictEqual(
+          await Array.fromAsync(
+            repo.findFollowedBots(new URL(seed.followeeId)),
+          ),
+          ["bot"],
+        );
+
+        // removeFollower() exercises the migrated follow_requests rows:
+        const removed = await repo.removeFollower(
+          "bot",
+          new URL(seed.followRequestId),
+          new URL(seed.followerId),
+        );
+        assert.ok(removed != null);
+
+        // migrate() is idempotent:
+        await repo.migrate("bot");
+        assert.deepStrictEqual(await repo.countMessages("bot"), 1);
+      } finally {
+        repo.close();
+      }
+
+      // Reopening the migrated database works without another rebuild:
+      const repo2 = new SqliteRepository({ path });
+      try {
+        assert.deepStrictEqual(await repo2.countMessages("bot"), 1);
+      } finally {
+        repo2.close();
+      }
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("does not touch fresh databases", async () => {
+    const repo = createSqliteRepository();
+    try {
+      await repo.migrate("bot");
+      assert.deepStrictEqual(await repo.countMessages("bot"), 0);
+    } finally {
+      repo.close();
+    }
+  });
+});
+
+describe("SqliteRepository.migrate() with empty-string identifiers", () => {
+  test("does not reassign data stored under an empty identifier", async () => {
+    const repo = createSqliteRepository();
+    try {
+      // A fresh 0.5 database has no legacy marker, so data stored under
+      // the empty-string identifier must never be adopted by migrate():
+      await repo.setKeyPairs("", keyPairs);
+      await repo.migrate("bot");
+      assert.deepStrictEqual(await repo.getKeyPairs(""), keyPairs);
+      assert.deepStrictEqual(await repo.getKeyPairs("bot"), undefined);
+    } finally {
+      repo.close();
+    }
+  });
+
+  test("adopts legacy rows only once", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "botkit-sqlite-test-"));
+    try {
+      const path = join(dir, "legacy.db");
+      const db = new DatabaseSync(path);
+      db.exec(`
+        CREATE TABLE key_pairs (
+          id INTEGER PRIMARY KEY,
+          private_key_jwk TEXT NOT NULL,
+          public_key_jwk TEXT NOT NULL
+        )
+      `);
+      db.close();
+
+      const repo = new SqliteRepository({ path });
+      try {
+        await repo.migrate("bot");
+        // After adoption, rows written under the empty-string identifier
+        // stay put even if migrate() is called again:
+        await repo.setKeyPairs("", keyPairs);
+        await repo.migrate("bot2");
+        assert.deepStrictEqual(await repo.getKeyPairs(""), keyPairs);
+        assert.deepStrictEqual(await repo.getKeyPairs("bot2"), undefined);
+      } finally {
+        repo.close();
+      }
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+});
diff --git a/packages/botkit-sqlite/src/mod.ts b/packages/botkit-sqlite/src/mod.ts
index 8423c18..d73f3c8 100644
--- a/packages/botkit-sqlite/src/mod.ts
+++ b/packages/botkit-sqlite/src/mod.ts
@@ -13,11 +13,12 @@
 //
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
-import type {
-  Repository,
-  RepositoryGetFollowersOptions,
-  RepositoryGetMessagesOptions,
-  Uuid,
+import {
+  ActorScopedRepository,
+  type Repository,
+  type RepositoryGetFollowersOptions,
+  type RepositoryGetMessagesOptions,
+  type Uuid,
 } from "@fedify/botkit/repository";
 import { exportJwk, importJwk } from "@fedify/fedify/sig";
 import {
@@ -89,95 +90,356 @@ export class SqliteRepository implements Repository, Disposable {
     this.db.close();
   }
 
+  private tableExists(table: string): boolean {
+    const stmt = this.db.prepare(`
+      SELECT COUNT(*) AS count FROM sqlite_master
+      WHERE type = 'table' AND name = ?
+    `);
+    const row = stmt.get(table) as { count: number };
+    return row.count > 0;
+  }
+
+  private hasBotIdColumn(table: string): boolean {
+    const stmt = this.db.prepare(`
+      SELECT COUNT(*) AS count FROM pragma_table_info(?)
+      WHERE name = 'bot_id'
+    `);
+    const row = stmt.get(table) as { count: number };
+    return row.count > 0;
+  }
+
+  /**
+   * Rebuilds tables created by \@fedify/botkit-sqlite 0.4 or earlier, which
+   * had no `bot_id` column, into the bot-scoped schema.  Existing rows get
+   * the empty-string bot ID; use {@link SqliteRepository.migrate} to assign
+   * them to a bot actor identifier.
+   */
+  private rebuildLegacyTables(): void {
+    const tables = [
+      "key_pairs",
+      "messages",
+      "followers",
+      "follow_requests",
+      "sent_follows",
+      "followees",
+      "poll_votes",
+    ].filter((table) => this.tableExists(table) && !this.hasBotIdColumn(table));
+    if (tables.length < 1) return;
+    logger.info(
+      "Rebuilding legacy tables without a bot_id column: {tables}.",
+      { tables },
+    );
+    // The marker lets migrate() distinguish rows carried over from a legacy
+    // database (bot_id = '') from data legitimately stored under an
+    // empty-string identifier:
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS botkit_metadata (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      )
+    `);
+    // SQLite cannot add a column to a composite primary key, so the tables
+    // are rebuilt (create new, copy, drop, rename) in a single transaction.
+    // Foreign key enforcement is turned off during the rebuild since
+    // follow_requests references followers.
+    this.db.exec("PRAGMA foreign_keys = OFF;");
+    this.db.exec("BEGIN TRANSACTION");
+    try {
+      if (tables.includes("key_pairs")) {
+        // The primary key does not change; adding the column suffices:
+        this.db.exec(`
+          ALTER TABLE key_pairs ADD COLUMN bot_id TEXT NOT NULL DEFAULT ''
+        `);
+      }
+      if (tables.includes("messages")) {
+        this.db.exec(`
+          CREATE TABLE messages_new (
+            bot_id TEXT NOT NULL,
+            id TEXT NOT NULL,
+            activity_json TEXT NOT NULL,
+            published INTEGER,
+            PRIMARY KEY (bot_id, id)
+          )
+        `);
+        this.db.exec(`
+          INSERT INTO messages_new (bot_id, id, activity_json, published)
+          SELECT '', id, activity_json, published FROM messages
+        `);
+        this.db.exec("DROP TABLE messages");
+        this.db.exec("ALTER TABLE messages_new RENAME TO messages");
+      }
+      if (tables.includes("followers")) {
+        this.db.exec(`
+          CREATE TABLE followers_new (
+            bot_id TEXT NOT NULL,
+            follower_id TEXT NOT NULL,
+            actor_json TEXT NOT NULL,
+            PRIMARY KEY (bot_id, follower_id)
+          )
+        `);
+        this.db.exec(`
+          INSERT INTO followers_new (bot_id, follower_id, actor_json)
+          SELECT '', follower_id, actor_json FROM followers
+        `);
+        this.db.exec("DROP TABLE followers");
+        this.db.exec("ALTER TABLE followers_new RENAME TO followers");
+      }
+      if (tables.includes("follow_requests")) {
+        this.db.exec(`
+          CREATE TABLE follow_requests_new (
+            bot_id TEXT NOT NULL,
+            follow_request_id TEXT NOT NULL,
+            follower_id TEXT NOT NULL,
+            PRIMARY KEY (bot_id, follow_request_id),
+            FOREIGN KEY (bot_id, follower_id)
+              REFERENCES followers(bot_id, follower_id)
+          )
+        `);
+        this.db.exec(`
+          INSERT INTO follow_requests_new
+            (bot_id, follow_request_id, follower_id)
+          SELECT '', follow_request_id, follower_id FROM follow_requests
+        `);
+        this.db.exec("DROP TABLE follow_requests");
+        this.db.exec(
+          "ALTER TABLE follow_requests_new RENAME TO follow_requests",
+        );
+      }
+      if (tables.includes("sent_follows")) {
+        this.db.exec(`
+          CREATE TABLE sent_follows_new (
+            bot_id TEXT NOT NULL,
+            id TEXT NOT NULL,
+            follow_json TEXT NOT NULL,
+            PRIMARY KEY (bot_id, id)
+          )
+        `);
+        this.db.exec(`
+          INSERT INTO sent_follows_new (bot_id, id, follow_json)
+          SELECT '', id, follow_json FROM sent_follows
+        `);
+        this.db.exec("DROP TABLE sent_follows");
+        this.db.exec("ALTER TABLE sent_follows_new RENAME TO sent_follows");
+      }
+      if (tables.includes("followees")) {
+        this.db.exec(`
+          CREATE TABLE followees_new (
+            bot_id TEXT NOT NULL,
+            followee_id TEXT NOT NULL,
+            follow_json TEXT NOT NULL,
+            PRIMARY KEY (bot_id, followee_id)
+          )
+        `);
+        this.db.exec(`
+          INSERT INTO followees_new (bot_id, followee_id, follow_json)
+          SELECT '', followee_id, follow_json FROM followees
+        `);
+        this.db.exec("DROP TABLE followees");
+        this.db.exec("ALTER TABLE followees_new RENAME TO followees");
+      }
+      if (tables.includes("poll_votes")) {
+        this.db.exec(`
+          CREATE TABLE poll_votes_new (
+            bot_id TEXT NOT NULL,
+            message_id TEXT NOT NULL,
+            voter_id TEXT NOT NULL,
+            option TEXT NOT NULL,
+            PRIMARY KEY (bot_id, message_id, voter_id, option)
+          )
+        `);
+        this.db.exec(`
+          INSERT INTO poll_votes_new (bot_id, message_id, voter_id, option)
+          SELECT '', message_id, voter_id, option FROM poll_votes
+        `);
+        this.db.exec("DROP TABLE poll_votes");
+        this.db.exec("ALTER TABLE poll_votes_new RENAME TO poll_votes");
+      }
+      this.db.exec(`
+        INSERT OR REPLACE INTO botkit_metadata (key, value)
+        VALUES ('legacy_data', '1')
+      `);
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      this.db.exec("PRAGMA foreign_keys = ON;");
+      throw error;
+    }
+    this.db.exec("PRAGMA foreign_keys = ON;");
+    logger.info("Finished rebuilding legacy tables.");
+  }
+
+  /**
+   * Migrates data stored by \@fedify/botkit-sqlite 0.4 or earlier, which was
+   * not scoped by bot actor identifiers, so that it belongs to the given
+   * identifier.  Rows carried over from a legacy database have the
+   * empty-string bot ID; this method assigns them to the identifier in
+   * a single transaction.  It only acts when the database was actually
+   * rebuilt from a legacy schema, so data legitimately stored under an
+   * empty-string identifier is never touched, and calling it again is
+   * a no-op.
+   * @param identifier The identifier of the bot actor that adopts the legacy
+   *                   data.
+   * @since 0.5.0
+   */
+  migrate(identifier: string): Promise<void> {
+    if (!this.tableExists("botkit_metadata")) return Promise.resolve();
+    const marker = this.db.prepare(
+      "SELECT value FROM botkit_metadata WHERE key = 'legacy_data'",
+    ).get() as { value: string } | undefined;
+    if (marker == null) return Promise.resolve();
+    this.db.exec("BEGIN TRANSACTION");
+    // Updating followers and follow_requests rows in tandem temporarily
+    // breaks the foreign key between them; defer the check to the commit:
+    this.db.exec("PRAGMA defer_foreign_keys = ON");
+    try {
+      for (
+        const table of [
+          "key_pairs",
+          "messages",
+          "followers",
+          "follow_requests",
+          "sent_follows",
+          "followees",
+          "poll_votes",
+        ]
+      ) {
+        this.db.prepare(`UPDATE ${table} SET bot_id = ? WHERE bot_id = ''`)
+          .run(identifier);
+      }
+      this.db.exec("DELETE FROM botkit_metadata WHERE key = 'legacy_data'");
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+    return Promise.resolve();
+  }
+
   private initializeTables(): void {
+    this.rebuildLegacyTables();
+
     // Key pairs table
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS key_pairs (
         id INTEGER PRIMARY KEY,
+        bot_id TEXT NOT NULL,
         private_key_jwk TEXT NOT NULL,
         public_key_jwk TEXT NOT NULL
       )
     `);
 
+    // Create index on bot_id for efficient per-bot lookup
+    this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_key_pairs_bot_id ON key_pairs(bot_id)
+    `);
+
     // Messages table
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS messages (
-        id TEXT PRIMARY KEY,
+        bot_id TEXT NOT NULL,
+        id TEXT NOT NULL,
         activity_json TEXT NOT NULL,
-        published INTEGER
+        published INTEGER,
+        PRIMARY KEY (bot_id, id)
       )
     `);
 
     // Create index on published timestamp for efficient ordering
     this.db.exec(`
-      CREATE INDEX IF NOT EXISTS idx_messages_published ON messages(published)
+      CREATE INDEX IF NOT EXISTS idx_messages_bot_published
+      ON messages(bot_id, published)
     `);
 
     // Followers table
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS followers (
-        follower_id TEXT PRIMARY KEY,
-        actor_json TEXT NOT NULL
+        bot_id TEXT NOT NULL,
+        follower_id TEXT NOT NULL,
+        actor_json TEXT NOT NULL,
+        PRIMARY KEY (bot_id, follower_id)
       )
     `);
 
     // Follow requests mapping table
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS follow_requests (
-        follow_request_id TEXT PRIMARY KEY,
+        bot_id TEXT NOT NULL,
+        follow_request_id TEXT NOT NULL,
         follower_id TEXT NOT NULL,
-        FOREIGN KEY (follower_id) REFERENCES followers(follower_id)
+        PRIMARY KEY (bot_id, follow_request_id),
+        FOREIGN KEY (bot_id, follower_id)
+          REFERENCES followers(bot_id, follower_id)
       )
     `);
 
     // Sent follows table
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS sent_follows (
-        id TEXT PRIMARY KEY,
-        follow_json TEXT NOT NULL
+        bot_id TEXT NOT NULL,
+        id TEXT NOT NULL,
+        follow_json TEXT NOT NULL,
+        PRIMARY KEY (bot_id, id)
       )
     `);
 
     // Followees table
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS followees (
-        followee_id TEXT PRIMARY KEY,
-        follow_json TEXT NOT NULL
+        bot_id TEXT NOT NULL,
+        followee_id TEXT NOT NULL,
+        follow_json TEXT NOT NULL,
+        PRIMARY KEY (bot_id, followee_id)
       )
     `);
 
+    // Create index for reverse lookup of bots following an actor
+    this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_followees_followee_id
+      ON followees(followee_id)
+    `);
+
     // Poll votes table
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS poll_votes (
+        bot_id TEXT NOT NULL,
         message_id TEXT NOT NULL,
         voter_id TEXT NOT NULL,
         option TEXT NOT NULL,
-        PRIMARY KEY (message_id, voter_id, option)
+        PRIMARY KEY (bot_id, message_id, voter_id, option)
       )
     `);
 
     // Create index for efficient vote counting
     this.db.exec(`
-      CREATE INDEX IF NOT EXISTS idx_poll_votes_message_option 
-      ON poll_votes(message_id, option)
+      CREATE INDEX IF NOT EXISTS idx_poll_votes_bot_message_option
+      ON poll_votes(bot_id, message_id, option)
     `);
   }
 
-  async setKeyPairs(keyPairs: CryptoKeyPair[]): Promise<void> {
-    const deleteStmt = this.db.prepare("DELETE FROM key_pairs");
+  async setKeyPairs(
+    identifier: string,
+    keyPairs: CryptoKeyPair[],
+  ): Promise<void> {
+    const deleteStmt = this.db.prepare(
+      "DELETE FROM key_pairs WHERE bot_id = ?",
+    );
     const insertStmt = this.db.prepare(`
-      INSERT INTO key_pairs (private_key_jwk, public_key_jwk) 
-      VALUES (?, ?)
+      INSERT INTO key_pairs (bot_id, private_key_jwk, public_key_jwk)
+      VALUES (?, ?, ?)
     `);
 
     this.db.exec("BEGIN TRANSACTION");
     try {
-      deleteStmt.run();
+      deleteStmt.run(identifier);
 
       for (const keyPair of keyPairs) {
         const privateJwk = await exportJwk(keyPair.privateKey);
         const publicJwk = await exportJwk(keyPair.publicKey);
-        insertStmt.run(JSON.stringify(privateJwk), JSON.stringify(publicJwk));
+        insertStmt.run(
+          identifier,
+          JSON.stringify(privateJwk),
+          JSON.stringify(publicJwk),
+        );
       }
 
       this.db.exec("COMMIT");
@@ -187,11 +449,12 @@ export class SqliteRepository implements Repository, Disposable {
     }
   }
 
-  async getKeyPairs(): Promise<CryptoKeyPair[] | undefined> {
+  async getKeyPairs(identifier: string): Promise<CryptoKeyPair[] | undefined> {
     const stmt = this.db.prepare(`
       SELECT private_key_jwk, public_key_jwk FROM key_pairs
+      WHERE bot_id = ? ORDER BY id
     `);
-    const rows = stmt.all() as Array<{
+    const rows = stmt.all(identifier) as Array<{
       private_key_jwk: string;
       public_key_jwk: string;
     }>;
@@ -212,10 +475,14 @@ export class SqliteRepository implements Repository, Disposable {
     return keyPairs;
   }
 
-  async addMessage(id: Uuid, activity: Create | Announce): Promise<void> {
+  async addMessage(
+    identifier: string,
+    id: Uuid,
+    activity: Create | Announce,
+  ): Promise<void> {
     const stmt = this.db.prepare(`
-      INSERT INTO messages (id, activity_json, published) 
-      VALUES (?, ?, ?)
+      INSERT INTO messages (bot_id, id, activity_json, published)
+      VALUES (?, ?, ?, ?)
     `);
 
     const activityJson = JSON.stringify(
@@ -223,19 +490,22 @@ export class SqliteRepository implements Repository, Disposable {
     );
     const published = activity.published?.epochMilliseconds ?? null;
 
-    stmt.run(id, activityJson, published);
+    stmt.run(identifier, id, activityJson, published);
   }
 
   async updateMessage(
+    identifier: string,
     id: Uuid,
     updater: (
       existing: Create | Announce,
     ) => Create | Announce | undefined | Promise<Create | Announce | undefined>,
   ): Promise<boolean> {
     const selectStmt = this.db.prepare(`
-      SELECT activity_json FROM messages WHERE id = ?
+      SELECT activity_json FROM messages WHERE bot_id = ? AND id = ?
     `);
-    const row = selectStmt.get(id) as { activity_json: string } | undefined;
+    const row = selectStmt.get(identifier, id) as
+      | { activity_json: string }
+      | undefined;
 
     if (!row) return false;
 
@@ -250,9 +520,9 @@ export class SqliteRepository implements Repository, Disposable {
     if (newActivity == null) return false;
 
     const updateStmt = this.db.prepare(`
-      UPDATE messages 
-      SET activity_json = ?, published = ? 
-      WHERE id = ?
+      UPDATE messages
+      SET activity_json = ?, published = ?
+      WHERE bot_id = ? AND id = ?
     `);
 
     const newActivityJson = JSON.stringify(
@@ -260,22 +530,27 @@ export class SqliteRepository implements Repository, Disposable {
     );
     const published = newActivity.published?.epochMilliseconds ?? null;
 
-    updateStmt.run(newActivityJson, published, id);
+    updateStmt.run(newActivityJson, published, identifier, id);
     return true;
   }
 
-  async removeMessage(id: Uuid): Promise<Create | Announce | undefined> {
+  async removeMessage(
+    identifier: string,
+    id: Uuid,
+  ): Promise<Create | Announce | undefined> {
     const selectStmt = this.db.prepare(`
-      SELECT activity_json FROM messages WHERE id = ?
+      SELECT activity_json FROM messages WHERE bot_id = ? AND id = ?
     `);
-    const row = selectStmt.get(id) as { activity_json: string } | undefined;
+    const row = selectStmt.get(identifier, id) as
+      | { activity_json: string }
+      | undefined;
 
     if (!row) return undefined;
 
     const deleteStmt = this.db.prepare(`
-      DELETE FROM messages WHERE id = ?
+      DELETE FROM messages WHERE bot_id = ? AND id = ?
     `);
-    deleteStmt.run(id);
+    deleteStmt.run(identifier, id);
 
     try {
       const activityData = JSON.parse(row.activity_json);
@@ -292,12 +567,13 @@ export class SqliteRepository implements Repository, Disposable {
   }
 
   async *getMessages(
+    identifier: string,
     options: RepositoryGetMessagesOptions = {},
   ): AsyncIterable<Create | Announce> {
     const { order = "newest", until, since, limit } = options;
 
-    let sql = "SELECT activity_json FROM messages WHERE 1=1";
-    const params: (number | string)[] = [];
+    let sql = "SELECT activity_json FROM messages WHERE bot_id = ?";
+    const params: (number | string)[] = [identifier];
 
     if (since != null) {
       sql += " AND published >= ?";
@@ -336,11 +612,16 @@ export class SqliteRepository implements Repository, Disposable {
     }
   }
 
-  async getMessage(id: Uuid): Promise<Create | Announce | undefined> {
+  async getMessage(
+    identifier: string,
+    id: Uuid,
+  ): Promise<Create | Announce | undefined> {
     const stmt = this.db.prepare(`
-      SELECT activity_json FROM messages WHERE id = ?
+      SELECT activity_json FROM messages WHERE bot_id = ? AND id = ?
     `);
-    const row = stmt.get(id) as { activity_json: string } | undefined;
+    const row = stmt.get(identifier, id) as
+      | { activity_json: string }
+      | undefined;
 
     if (!row) return undefined;
 
@@ -358,13 +639,19 @@ export class SqliteRepository implements Repository, Disposable {
     return undefined;
   }
 
-  countMessages(): Promise<number> {
-    const stmt = this.db.prepare("SELECT COUNT(*) as count FROM messages");
-    const row = stmt.get() as { count: number };
+  countMessages(identifier: string): Promise<number> {
+    const stmt = this.db.prepare(
+      "SELECT COUNT(*) as count FROM messages WHERE bot_id = ?",
+    );
+    const row = stmt.get(identifier) as { count: number };
     return Promise.resolve(row.count);
   }
 
-  async addFollower(followRequestId: URL, follower: Actor): Promise<void> {
+  async addFollower(
+    identifier: string,
+    followRequestId: URL,
+    follower: Actor,
+  ): Promise<void> {
     if (follower.id == null) {
       throw new TypeError("The follower ID is missing.");
     }
@@ -374,19 +661,24 @@ export class SqliteRepository implements Repository, Disposable {
     );
 
     const insertFollowerStmt = this.db.prepare(`
-      INSERT OR REPLACE INTO followers (follower_id, actor_json) 
-      VALUES (?, ?)
+      INSERT OR REPLACE INTO followers (bot_id, follower_id, actor_json)
+      VALUES (?, ?, ?)
     `);
 
     const insertRequestStmt = this.db.prepare(`
-      INSERT OR REPLACE INTO follow_requests (follow_request_id, follower_id) 
-      VALUES (?, ?)
+      INSERT OR REPLACE INTO follow_requests
+        (bot_id, follow_request_id, follower_id)
+      VALUES (?, ?, ?)
     `);
 
     this.db.exec("BEGIN TRANSACTION");
     try {
-      insertFollowerStmt.run(follower.id.href, followerJson);
-      insertRequestStmt.run(followRequestId.href, follower.id.href);
+      insertFollowerStmt.run(identifier, follower.id.href, followerJson);
+      insertRequestStmt.run(
+        identifier,
+        followRequestId.href,
+        follower.id.href,
+      );
       this.db.exec("COMMIT");
     } catch (error) {
       this.db.exec("ROLLBACK");
@@ -395,37 +687,45 @@ export class SqliteRepository implements Repository, Disposable {
   }
 
   async removeFollower(
+    identifier: string,
     followRequestId: URL,
     actorId: URL,
   ): Promise<Actor | undefined> {
     // Check if the follow request exists and matches the actor
     const checkStmt = this.db.prepare(`
-      SELECT fr.follower_id, f.actor_json 
-      FROM follow_requests fr 
-      JOIN followers f ON fr.follower_id = f.follower_id 
-      WHERE fr.follow_request_id = ? AND fr.follower_id = ?
+      SELECT fr.follower_id, f.actor_json
+      FROM follow_requests fr
+      JOIN followers f
+        ON fr.bot_id = f.bot_id AND fr.follower_id = f.follower_id
+      WHERE fr.bot_id = ? AND fr.follow_request_id = ? AND fr.follower_id = ?
     `);
 
-    const row = checkStmt.get(followRequestId.href, actorId.href) as {
-      follower_id: string;
-      actor_json: string;
-    } | undefined;
+    const row = checkStmt.get(
+      identifier,
+      followRequestId.href,
+      actorId.href,
+    ) as
+      | {
+        follower_id: string;
+        actor_json: string;
+      }
+      | undefined;
 
     if (!row) return undefined;
 
     // Remove the follower and follow request
     const deleteRequestStmt = this.db.prepare(`
-      DELETE FROM follow_requests WHERE follow_request_id = ?
+      DELETE FROM follow_requests WHERE bot_id = ? AND follow_request_id = ?
     `);
 
     const deleteFollowerStmt = this.db.prepare(`
-      DELETE FROM followers WHERE follower_id = ?
+      DELETE FROM followers WHERE bot_id = ? AND follower_id = ?
     `);
 
     this.db.exec("BEGIN TRANSACTION");
     try {
-      deleteRequestStmt.run(followRequestId.href);
-      deleteFollowerStmt.run(actorId.href);
+      deleteRequestStmt.run(identifier, followRequestId.href);
+      deleteFollowerStmt.run(identifier, actorId.href);
       this.db.exec("COMMIT");
     } catch (error) {
       this.db.exec("ROLLBACK");
@@ -446,21 +746,23 @@ export class SqliteRepository implements Repository, Disposable {
     return undefined;
   }
 
-  hasFollower(followerId: URL): Promise<boolean> {
+  hasFollower(identifier: string, followerId: URL): Promise<boolean> {
     const stmt = this.db.prepare(`
-      SELECT 1 FROM followers WHERE follower_id = ?
+      SELECT 1 FROM followers WHERE bot_id = ? AND follower_id = ?
     `);
-    const row = stmt.get(followerId.href);
+    const row = stmt.get(identifier, followerId.href);
     return Promise.resolve(row != null);
   }
 
   async *getFollowers(
+    identifier: string,
     options: RepositoryGetFollowersOptions = {},
   ): AsyncIterable<Actor> {
     const { offset = 0, limit } = options;
 
-    let sql = "SELECT actor_json FROM followers ORDER BY follower_id";
-    const params: number[] = [];
+    let sql =
+      "SELECT actor_json FROM followers WHERE bot_id = ? ORDER BY follower_id";
+    const params: (number | string)[] = [identifier];
 
     if (limit != null) {
       sql += " LIMIT ? OFFSET ?";
@@ -488,40 +790,56 @@ export class SqliteRepository implements Repository, Disposable {
     }
   }
 
-  countFollowers(): Promise<number> {
-    const stmt = this.db.prepare("SELECT COUNT(*) as count FROM followers");
-    const row = stmt.get() as { count: number };
+  countFollowers(identifier: string): Promise<number> {
+    const stmt = this.db.prepare(
+      "SELECT COUNT(*) as count FROM followers WHERE bot_id = ?",
+    );
+    const row = stmt.get(identifier) as { count: number };
     return Promise.resolve(row.count);
   }
 
-  async addSentFollow(id: Uuid, follow: Follow): Promise<void> {
+  async addSentFollow(
+    identifier: string,
+    id: Uuid,
+    follow: Follow,
+  ): Promise<void> {
     const stmt = this.db.prepare(`
-      INSERT OR REPLACE INTO sent_follows (id, follow_json) 
-      VALUES (?, ?)
+      INSERT OR REPLACE INTO sent_follows (bot_id, id, follow_json)
+      VALUES (?, ?, ?)
     `);
 
     const followJson = JSON.stringify(
       await follow.toJsonLd({ format: "compact" }),
     );
 
-    stmt.run(id, followJson);
+    stmt.run(identifier, id, followJson);
   }
 
-  async removeSentFollow(id: Uuid): Promise<Follow | undefined> {
-    const follow = await this.getSentFollow(id);
+  async removeSentFollow(
+    identifier: string,
+    id: Uuid,
+  ): Promise<Follow | undefined> {
+    const follow = await this.getSentFollow(identifier, id);
     if (follow == null) return undefined;
 
-    const stmt = this.db.prepare("DELETE FROM sent_follows WHERE id = ?");
-    stmt.run(id);
+    const stmt = this.db.prepare(
+      "DELETE FROM sent_follows WHERE bot_id = ? AND id = ?",
+    );
+    stmt.run(identifier, id);
 
     return follow;
   }
 
-  async getSentFollow(id: Uuid): Promise<Follow | undefined> {
+  async getSentFollow(
+    identifier: string,
+    id: Uuid,
+  ): Promise<Follow | undefined> {
     const stmt = this.db.prepare(`
-      SELECT follow_json FROM sent_follows WHERE id = ?
+      SELECT follow_json FROM sent_follows WHERE bot_id = ? AND id = ?
     `);
-    const row = stmt.get(id) as { follow_json: string } | undefined;
+    const row = stmt.get(identifier, id) as
+      | { follow_json: string }
+      | undefined;
 
     if (!row) return undefined;
 
@@ -534,34 +852,46 @@ export class SqliteRepository implements Repository, Disposable {
     }
   }
 
-  async addFollowee(followeeId: URL, follow: Follow): Promise<void> {
+  async addFollowee(
+    identifier: string,
+    followeeId: URL,
+    follow: Follow,
+  ): Promise<void> {
     const stmt = this.db.prepare(`
-      INSERT OR REPLACE INTO followees (followee_id, follow_json) 
-      VALUES (?, ?)
+      INSERT OR REPLACE INTO followees (bot_id, followee_id, follow_json)
+      VALUES (?, ?, ?)
     `);
 
     const followJson = JSON.stringify(
       await follow.toJsonLd({ format: "compact" }),
     );
 
-    stmt.run(followeeId.href, followJson);
+    stmt.run(identifier, followeeId.href, followJson);
   }
 
-  async removeFollowee(followeeId: URL): Promise<Follow | undefined> {
-    const follow = await this.getFollowee(followeeId);
+  async removeFollowee(
+    identifier: string,
+    followeeId: URL,
+  ): Promise<Follow | undefined> {
+    const follow = await this.getFollowee(identifier, followeeId);
     if (follow == null) return undefined;
 
-    const stmt = this.db.prepare("DELETE FROM followees WHERE followee_id = ?");
-    stmt.run(followeeId.href);
+    const stmt = this.db.prepare(
+      "DELETE FROM followees WHERE bot_id = ? AND followee_id = ?",
+    );
+    stmt.run(identifier, followeeId.href);
 
     return follow;
   }
 
-  async getFollowee(followeeId: URL): Promise<Follow | undefined> {
+  async getFollowee(
+    identifier: string,
+    followeeId: URL,
+  ): Promise<Follow | undefined> {
     const stmt = this.db.prepare(`
-      SELECT follow_json FROM followees WHERE followee_id = ?
+      SELECT follow_json FROM followees WHERE bot_id = ? AND followee_id = ?
     `);
-    const row = stmt.get(followeeId.href) as
+    const row = stmt.get(identifier, followeeId.href) as
       | { follow_json: string }
       | undefined;
 
@@ -579,34 +909,50 @@ export class SqliteRepository implements Repository, Disposable {
     }
   }
 
-  vote(messageId: Uuid, voterId: URL, option: string): Promise<void> {
+  async *findFollowedBots(followeeId: URL): AsyncIterable<string> {
     const stmt = this.db.prepare(`
-      INSERT OR IGNORE INTO poll_votes (message_id, voter_id, option) 
-      VALUES (?, ?, ?)
+      SELECT bot_id FROM followees WHERE followee_id = ? ORDER BY bot_id
+    `);
+    const rows = stmt.all(followeeId.href) as { bot_id: string }[];
+    for (const row of rows) yield row.bot_id;
+  }
+
+  vote(
+    identifier: string,
+    messageId: Uuid,
+    voterId: URL,
+    option: string,
+  ): Promise<void> {
+    const stmt = this.db.prepare(`
+      INSERT OR IGNORE INTO poll_votes (bot_id, message_id, voter_id, option)
+      VALUES (?, ?, ?, ?)
     `);
 
-    stmt.run(messageId, voterId.href, option);
+    stmt.run(identifier, messageId, voterId.href, option);
     return Promise.resolve();
   }
 
-  countVoters(messageId: Uuid): Promise<number> {
+  countVoters(identifier: string, messageId: Uuid): Promise<number> {
     const stmt = this.db.prepare(`
-      SELECT COUNT(DISTINCT voter_id) as count 
-      FROM poll_votes 
-      WHERE message_id = ?
+      SELECT COUNT(DISTINCT voter_id) as count
+      FROM poll_votes
+      WHERE bot_id = ? AND message_id = ?
     `);
-    const row = stmt.get(messageId) as { count: number };
+    const row = stmt.get(identifier, messageId) as { count: number };
     return Promise.resolve(row.count);
   }
 
-  countVotes(messageId: Uuid): Promise<Readonly<Record<string, number>>> {
+  countVotes(
+    identifier: string,
+    messageId: Uuid,
+  ): Promise<Readonly<Record<string, number>>> {
     const stmt = this.db.prepare(`
-      SELECT option, COUNT(*) as count 
-      FROM poll_votes 
-      WHERE message_id = ? 
+      SELECT option, COUNT(*) as count
+      FROM poll_votes
+      WHERE bot_id = ? AND message_id = ?
       GROUP BY option
     `);
-    const rows = stmt.all(messageId) as Array<{
+    const rows = stmt.all(identifier, messageId) as Array<{
       option: string;
       count: number;
     }>;
@@ -618,4 +964,8 @@ export class SqliteRepository implements Repository, Disposable {
 
     return Promise.resolve(result);
   }
+
+  forIdentifier(identifier: string): ActorScopedRepository {
+    return new ActorScopedRepository(this, identifier);
+  }
 }
diff --git a/packages/botkit/deno.json b/packages/botkit/deno.json
index b10d997..e392115 100644
--- a/packages/botkit/deno.json
+++ b/packages/botkit/deno.json
@@ -8,6 +8,7 @@
     "./emoji": "./src/emoji.ts",
     "./events": "./src/events.ts",
     "./follow": "./src/follow.ts",
+    "./instance": "./src/instance.ts",
     "./message": "./src/message.ts",
     "./poll": "./src/poll.ts",
     "./reaction": "./src/reaction.ts",
diff --git a/packages/botkit/package.json b/packages/botkit/package.json
index f696bbf..876f5c6 100644
--- a/packages/botkit/package.json
+++ b/packages/botkit/package.json
@@ -50,6 +50,10 @@
       "types": "./dist/follow.d.ts",
       "import": "./dist/follow.js"
     },
+    "./instance": {
+      "types": "./dist/instance.d.ts",
+      "import": "./dist/instance.js"
+    },
     "./message": {
       "types": "./dist/message.d.ts",
       "import": "./dist/message.js"
diff --git a/packages/botkit/src/bot-group.test.ts b/packages/botkit/src/bot-group.test.ts
new file mode 100644
index 0000000..f7af15b
--- /dev/null
+++ b/packages/botkit/src/bot-group.test.ts
@@ -0,0 +1,365 @@
+// BotKit by Fedify: A framework for creating ActivityPub bots
+// Copyright (C) 2025–2026 Hong Minhee <https://hongminhee.org/>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+import { type InboxContext, MemoryKvStore } from "@fedify/fedify/federation";
+import { Create, Follow, Note, Person, PUBLIC_COLLECTION } from "@fedify/vocab";
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { InstanceImpl } from "./instance-impl.ts";
+import type { BotProfile } from "./instance.ts";
+import { MemoryRepository } from "./repository.ts";
+
+function createInstance(): {
+  instance: InstanceImpl<void>;
+  repository: MemoryRepository;
+} {
+  const repository = new MemoryRepository();
+  const instance = new InstanceImpl<void>({
+    kv: new MemoryKvStore(),
+    repository,
+  });
+  return { instance, repository };
+}
+
+function regionProfile(identifier: string): BotProfile<void> | null {
+  if (!identifier.startsWith("region_")) return null;
+  const region = identifier.slice("region_".length);
+  return {
+    username: identifier,
+    name: `${region.toUpperCase()} Weather Bot`,
+  };
+}
+
+describe("dynamic bots", () => {
+  test("serve dispatcher-resolved actors", async () => {
+    const { instance } = createInstance();
+    let calls = 0;
+    instance.createBot((_ctx, identifier) => {
+      calls++;
+      return regionProfile(identifier);
+    });
+    const response = await instance.fetch(
+      new Request("https://example.com/ap/actor/region_kr", {
+        headers: { Accept: "application/activity+json" },
+      }),
+      undefined,
+    );
+    assert.deepStrictEqual(response.status, 200);
+    const actor = await response.json();
+    assert.deepStrictEqual(actor.preferredUsername, "region_kr");
+    assert.deepStrictEqual(actor.name, "KR Weather Bot");
+
+    const miss = await instance.fetch(
+      new Request("https://example.com/ap/actor/other", {
+        headers: { Accept: "application/activity+json" },
+      }),
+      undefined,
+    );
+    assert.deepStrictEqual(miss.status, 404);
+
+    // Resolution is memoized per context, so a dispatcher runs at most
+    // once per identifier within one context:
+    calls = 0;
+    const ctx = instance.federation.createContext(
+      new URL("https://example.com/"),
+      undefined,
+    );
+    await instance.resolveBot(ctx, "region_kr");
+    await instance.resolveBot(ctx, "region_kr");
+    await instance.resolveBot(ctx, "other");
+    await instance.resolveBot(ctx, "other");
+    assert.deepStrictEqual(calls, 2);
+  });
+
+  test("prefer static bots over dynamic dispatchers", async () => {
+    const { instance } = createInstance();
+    instance.createBot("region_kr", { username: "static-kr" });
+    instance.createBot((_ctx, identifier) => regionProfile(identifier));
+    const response = await instance.fetch(
+      new Request("https://example.com/ap/actor/region_kr", {
+        headers: { Accept: "application/activity+json" },
+      }),
+      undefined,
+    );
+    assert.deepStrictEqual(response.status, 200);
+    const actor = await response.json();
+    assert.deepStrictEqual(actor.preferredUsername, "static-kr");
+  });
+
+  test("probe dispatchers in registration order", async () => {
+    const { instance } = createInstance();
+    const probed: string[] = [];
+    instance.createBot((_ctx, identifier) => {
+      probed.push("first");
+      return identifier === "dual" ? { username: "first-bot" } : null;
+    });
+    instance.createBot((_ctx, identifier) => {
+      probed.push("second");
+      return identifier === "dual" ? { username: "second-bot" } : null;
+    });
+    const response = await instance.fetch(
+      new Request("https://example.com/ap/actor/dual", {
+        headers: { Accept: "application/activity+json" },
+      }),
+      undefined,
+    );
+    const actor = await response.json();
+    assert.deepStrictEqual(actor.preferredUsername, "first-bot");
+    assert.ok(!probed.includes("second"));
+  });
+
+  test("fall through to the next dispatcher on null", async () => {
+    const { instance } = createInstance();
+    const probed: string[] = [];
+    instance.createBot((_ctx, identifier) => {
+      probed.push("first");
+      return identifier === "somebody-else" ? { username: "first-bot" } : null;
+    });
+    instance.createBot((_ctx, identifier) => {
+      probed.push("second");
+      return regionProfile(identifier);
+    });
+    const response = await instance.fetch(
+      new Request("https://example.com/ap/actor/region_kr", {
+        headers: { Accept: "application/activity+json" },
+      }),
+      undefined,
+    );
+    assert.deepStrictEqual(response.status, 200);
+    const actor = await response.json();
+    assert.deepStrictEqual(actor.preferredUsername, "region_kr");
+    // The first dispatcher was probed, returned null, and the resolution
+    // fell through to the second:
+    assert.ok(probed.includes("first"));
+    assert.ok(probed.includes("second"));
+  });
+
+  test("read event handlers live from the group", async () => {
+    const { instance } = createInstance();
+    const group = instance.createBot(
+      (_ctx, identifier) => regionProfile(identifier),
+    );
+    // Resolve the bot once before any handler is registered:
+    await instance.fetch(
+      new Request("https://example.com/ap/actor/region_kr", {
+        headers: { Accept: "application/activity+json" },
+      }),
+      undefined,
+    );
+    // A handler registered afterwards must still fire:
+    const followed: string[] = [];
+    group.onFollow = (session) => void (followed.push(session.bot.identifier));
+    const ctx = instance.federation.createContext(
+      new URL("https://example.com/"),
+      undefined,
+    ) as InboxContext<void>;
+    Object.defineProperty(ctx, "recipient", {
+      value: null,
+      configurable: true,
+    });
+    Object.defineProperty(ctx, "sendActivity", {
+      value: () => Promise.resolve(),
+      configurable: true,
+    });
+    await instance.onFollowed(
+      ctx,
+      new Follow({
+        id: new URL("https://remote.example/follows/1"),
+        actor: new Person({
+          id: new URL("https://remote.example/actors/john"),
+          preferredUsername: "john",
+        }),
+        object: new URL("https://example.com/ap/actor/region_kr"),
+      }),
+    );
+    assert.deepStrictEqual(followed, ["region_kr"]);
+  });
+
+  test("resolve usernames through mapUsername", async () => {
+    const { instance } = createInstance();
+    instance.createBot(
+      (_ctx, identifier) => regionProfile(identifier),
+      {
+        mapUsername: (_ctx, username) =>
+          username.startsWith("region_") ? username : `region_${username}`,
+      },
+    );
+    const response = await instance.fetch(
+      new Request(
+        "https://example.com/.well-known/webfinger?resource=acct:kr@example.com",
+      ),
+      undefined,
+    );
+    assert.deepStrictEqual(response.status, 200);
+    const jrd = await response.json();
+    const self = jrd.links.find((link: { rel: string }) => link.rel === "self");
+    assert.deepStrictEqual(
+      self.href,
+      "https://example.com/ap/actor/region_kr",
+    );
+  });
+
+  test("fall back to username-as-identifier lookups", async () => {
+    const { instance } = createInstance();
+    instance.createBot((_ctx, identifier) => regionProfile(identifier));
+    const response = await instance.fetch(
+      new Request(
+        "https://example.com/.well-known/webfinger?resource=acct:region_kr@example.com",
+      ),
+      undefined,
+    );
+    assert.deepStrictEqual(response.status, 200);
+  });
+
+  test("require context data unless TContextData is void", () => {
+    const instance = new InstanceImpl<{ db: string }>({
+      kv: new MemoryKvStore(),
+      repository: new MemoryRepository(),
+    });
+    const group = instance.createBot((_ctx, identifier) => ({
+      username: identifier,
+    }));
+    // @ts-expect-error: contextData is required when TContextData is not
+    // void.
+    group.getSession("https://example.com", "someone").catch(() => {});
+    group.getSession("https://example.com", "someone", { db: "x" })
+      .catch(() => {});
+  });
+
+  test("create sessions for resolved identifiers", async () => {
+    const { instance } = createInstance();
+    const group = instance.createBot(
+      (_ctx, identifier) => regionProfile(identifier),
+    );
+    const session = await group.getSession(
+      "https://example.com",
+      "region_kr",
+    );
+    assert.deepStrictEqual(
+      session.actorId.href,
+      "https://example.com/ap/actor/region_kr",
+    );
+    assert.deepStrictEqual(session.bot.identifier, "region_kr");
+    assert.deepStrictEqual(session.bot.username, "region_kr");
+
+    await assert.rejects(
+      () => group.getSession("https://example.com", "nonexistent"),
+      TypeError,
+    );
+  });
+});
+
+describe("dynamic bots in routing and web pages", () => {
+  test("receive timeline messages via followees", async () => {
+    const { instance, repository } = createInstance();
+    const group = instance.createBot(
+      (_ctx, identifier) => regionProfile(identifier),
+    );
+    const events: string[] = [];
+    group.onMessage = (session) =>
+      void (events.push(`message:${session.bot.identifier}`));
+    const author = new Person({
+      id: new URL("https://example.com/ap/actor/john"),
+      preferredUsername: "john",
+    });
+    await repository.addFollowee(
+      "region_kr",
+      author.id!,
+      new Follow({
+        id: new URL(
+          "https://example.com/ap/actor/region_kr/follow/e35ff5d8-ede9-4f5e-9b83-4bfcd4c9a69c",
+        ),
+        actor: new URL("https://example.com/ap/actor/region_kr"),
+        object: author.id!,
+      }),
+    );
+    const ctx = instance.federation.createContext(
+      new URL("https://example.com/"),
+      undefined,
+    ) as InboxContext<void>;
+    Object.defineProperty(ctx, "recipient", {
+      value: null,
+      configurable: true,
+    });
+    await instance.onCreated(
+      ctx,
+      new Create({
+        id: new URL("https://remote.example/creates/1"),
+        actor: author,
+        to: PUBLIC_COLLECTION,
+        object: new Note({
+          id: new URL("https://remote.example/notes/1"),
+          attribution: author,
+          to: PUBLIC_COLLECTION,
+          content: "A timeline post",
+        }),
+      }),
+    );
+    assert.deepStrictEqual(events, ["message:region_kr"]);
+  });
+
+  test("serve dynamic bots' web pages", async () => {
+    const { instance } = createInstance();
+    instance.createBot((_ctx, identifier) => regionProfile(identifier));
+    const response = await instance.fetch(
+      new Request("https://example.com/@region_kr"),
+      undefined,
+    );
+    assert.deepStrictEqual(response.status, 200);
+    const html = await response.text();
+    assert.ok(html.includes("@region_kr@example.com"));
+
+    const miss = await instance.fetch(
+      new Request("https://example.com/@nonexistent"),
+      undefined,
+    );
+    assert.deepStrictEqual(miss.status, 404);
+  });
+});
+
+describe("mapUsername ownership", () => {
+  test("cannot map usernames to other bots' identifiers", async () => {
+    const { instance } = createInstance();
+    instance.createBot("staticbot", { username: "staticbot" });
+    instance.createBot(
+      (_ctx, identifier) => regionProfile(identifier),
+      {
+        // A hostile or buggy mapping pointing at a static bot's identifier:
+        mapUsername: () => "staticbot",
+      },
+    );
+    const response = await instance.fetch(
+      new Request(
+        "https://example.com/.well-known/webfinger?resource=acct:hijack@example.com",
+      ),
+      undefined,
+    );
+    assert.deepStrictEqual(response.status, 404);
+  });
+});
+
+describe("username-as-identifier fallback scope", () => {
+  test("does not expose static bots' internal identifiers", async () => {
+    const { instance } = createInstance();
+    instance.createBot("internal", { username: "mybot" });
+    const response = await instance.fetch(
+      new Request(
+        "https://example.com/.well-known/webfinger?resource=acct:internal@example.com",
+      ),
+      undefined,
+    );
+    assert.deepStrictEqual(response.status, 404);
+  });
+});
diff --git a/packages/botkit/src/bot-impl.test.ts b/packages/botkit/src/bot-impl.test.ts
index 752abb3..307490a 100644
--- a/packages/botkit/src/bot-impl.test.ts
+++ b/packages/botkit/src/bot-impl.test.ts
@@ -222,7 +222,7 @@ test("BotImpl.dispatchActor()", async () => {
   assert.ok(publicKey != null);
   assert.deepStrictEqual(publicKey.ownerId, actor.id);
   assert.ok(publicKey.publicKey != null);
-  const keys = await repository.getKeyPairs();
+  const keys = await repository.getKeyPairs("bot");
   assert.ok(keys != null);
   assert.deepStrictEqual(publicKey.publicKey, keys[0].publicKey);
   const assertionMethods = await Array.fromAsync(actor.getAssertionMethods());
@@ -267,7 +267,7 @@ test("BotImpl.dispatchActorKeyPairs()", async () => {
   );
   // Generation:
   const keyPairs = await bot.dispatchActorKeyPairs(ctx, "bot");
-  const storedKeyPairs = await repository.getKeyPairs();
+  const storedKeyPairs = await repository.getKeyPairs("bot");
   assert.deepStrictEqual(keyPairs, storedKeyPairs);
   // Retrieval:
   const keyPairs2 = await bot.dispatchActorKeyPairs(ctx, "bot");
@@ -298,6 +298,7 @@ test("BotImpl.dispatchFollowers()", async () => {
   assert.deepStrictEqual(empty, { items: [], nextCursor: null });
 
   await repository.addFollower(
+    "bot",
     new URL("https://example.com/actor/1#follow"),
     new Person({
       id: new URL("https://example.com/actor/1"),
@@ -306,6 +307,7 @@ test("BotImpl.dispatchFollowers()", async () => {
     }),
   );
   await repository.addFollower(
+    "bot",
     new URL("https://example.com/actor/2#follow"),
     new Person({
       id: new URL("https://example.com/actor/2"),
@@ -314,6 +316,7 @@ test("BotImpl.dispatchFollowers()", async () => {
     }),
   );
   await repository.addFollower(
+    "bot",
     new URL("https://example.com/actor/3#follow"),
     new Person({
       id: new URL("https://example.com/actor/3"),
@@ -393,6 +396,7 @@ test("BotImpl.countFollowers()", async () => {
   assert.deepStrictEqual(await bot.countFollowers(ctx, "non-existent"), null);
   assert.deepStrictEqual(await bot.countFollowers(ctx, "bot"), 0);
   await repository.addFollower(
+    "bot",
     new URL("https://example.com/actor/1#follow"),
     new Person({
       id: new URL("https://example.com/actor/1"),
@@ -401,6 +405,7 @@ test("BotImpl.countFollowers()", async () => {
     }),
   );
   await repository.addFollower(
+    "bot",
     new URL("https://example.com/actor/2#follow"),
     new Person({
       id: new URL("https://example.com/actor/2"),
@@ -409,6 +414,7 @@ test("BotImpl.countFollowers()", async () => {
     }),
   );
   await repository.addFollower(
+    "bot",
     new URL("https://example.com/actor/3#follow"),
     new Person({
       id: new URL("https://example.com/actor/3"),
@@ -467,6 +473,7 @@ test("BotImpl.getPermissionChecker()", async () => {
   assert.deepStrictEqual(nonFollower(directPost), false);
 
   await repository.addFollower(
+    "bot",
     new URL("https://example.com/actor/john#follow"),
     new Person({
       id: new URL("https://example.com/actor/john"),
@@ -529,6 +536,7 @@ test("BotImpl.dispatchOutbox()", async () => {
   });
 
   await repository.addMessage(
+    "bot",
     "78acb1ea-4ac6-46b7-bcd4-3a8965d8126e",
     new Create({
       id: new URL(
@@ -549,6 +557,7 @@ test("BotImpl.dispatchOutbox()", async () => {
     }),
   );
   await repository.addMessage(
+    "bot",
     "46442170-836d-4a0d-9142-f31242abe2f9",
     new Create({
       id: new URL(
@@ -569,6 +578,7 @@ test("BotImpl.dispatchOutbox()", async () => {
     }),
   );
   await repository.addMessage(
+    "bot",
     "8386a4c7-06f8-409f-ad72-2bba43e83363",
     new Create({
       id: new URL(
@@ -682,6 +692,7 @@ test("BotImpl.countOutbox()", async () => {
   assert.deepStrictEqual(await bot.countOutbox(ctx, "bot"), 0);
 
   await repository.addMessage(
+    "bot",
     "78acb1ea-4ac6-46b7-bcd4-3a8965d8126e",
     new Create({
       id: new URL(
@@ -700,6 +711,7 @@ test("BotImpl.countOutbox()", async () => {
     }),
   );
   await repository.addMessage(
+    "bot",
     "46442170-836d-4a0d-9142-f31242abe2f9",
     new Create({
       id: new URL(
@@ -718,6 +730,7 @@ test("BotImpl.countOutbox()", async () => {
     }),
   );
   await repository.addMessage(
+    "bot",
     "8386a4c7-06f8-409f-ad72-2bba43e83363",
     new Create({
       id: new URL(
@@ -749,11 +762,15 @@ test("BotImpl.dispatchFollow()", async () => {
     undefined,
   );
   assert.deepStrictEqual(
-    await bot.dispatchFollow(ctx, { id: crypto.randomUUID() }),
+    await bot.dispatchFollow(ctx, {
+      identifier: "bot",
+      id: crypto.randomUUID(),
+    }),
     null,
   );
 
   await repository.addSentFollow(
+    "bot",
     "b51f6ca8-53e6-4f7d-ac1f-d039e8c6df5a",
     new Follow({
       id: new URL(
@@ -765,6 +782,7 @@ test("BotImpl.dispatchFollow()", async () => {
     }),
   );
   const follow = await bot.dispatchFollow(ctx, {
+    identifier: "bot",
     id: "b51f6ca8-53e6-4f7d-ac1f-d039e8c6df5a",
   });
   assert.ok(follow instanceof Follow);
@@ -800,6 +818,7 @@ test("BotImpl.authorizeFollow()", async () => {
     undefined,
   );
   await repository.addSentFollow(
+    "bot",
     "b51f6ca8-53e6-4f7d-ac1f-d039e8c6df5a",
     new Follow({
       id: new URL(
@@ -823,14 +842,14 @@ test("BotImpl.authorizeFollow()", async () => {
   assert.ok(
     await bot.authorizeFollow(
       ctx,
-      { id: "b51f6ca8-53e6-4f7d-ac1f-d039e8c6df5a" },
+      { identifier: "bot", id: "b51f6ca8-53e6-4f7d-ac1f-d039e8c6df5a" },
     ),
   );
   setSignedKeyOwner(await new SessionImpl(bot, ctx).getActor());
   assert.ok(
     await bot.authorizeFollow(
       ctx,
-      { id: "b51f6ca8-53e6-4f7d-ac1f-d039e8c6df5a" },
+      { identifier: "bot", id: "b51f6ca8-53e6-4f7d-ac1f-d039e8c6df5a" },
     ),
   );
   setSignedKeyOwner(
@@ -839,7 +858,7 @@ test("BotImpl.authorizeFollow()", async () => {
   assert.deepStrictEqual(
     await bot.authorizeFollow(
       ctx,
-      { id: "b51f6ca8-53e6-4f7d-ac1f-d039e8c6df5a" },
+      { identifier: "bot", id: "b51f6ca8-53e6-4f7d-ac1f-d039e8c6df5a" },
     ),
     false,
   );
@@ -849,7 +868,7 @@ test("BotImpl.authorizeFollow()", async () => {
   assert.deepStrictEqual(
     await bot.authorizeFollow(
       ctx,
-      { id: crypto.randomUUID() },
+      { identifier: "bot", id: crypto.randomUUID() },
     ),
     false,
   );
@@ -867,11 +886,12 @@ test("BotImpl.dispatchCreate()", async () => {
     undefined,
   );
   assert.deepStrictEqual(
-    await bot.dispatchCreate(ctx, { id: "non-existent" }),
+    await bot.dispatchCreate(ctx, { identifier: "bot", id: "non-existent" }),
     null,
   );
 
   await repository.addMessage(
+    "bot",
     "78acb1ea-4ac6-46b7-bcd4-3a8965d8126e",
     new Create({
       id: new URL(
@@ -890,6 +910,7 @@ test("BotImpl.dispatchCreate()", async () => {
     }),
   );
   const create = await bot.dispatchCreate(ctx, {
+    identifier: "bot",
     id: "78acb1ea-4ac6-46b7-bcd4-3a8965d8126e",
   });
   assert.ok(create instanceof Create);
@@ -909,12 +930,14 @@ test("BotImpl.dispatchCreate()", async () => {
   ctx2.getSignedKeyOwner = () => Promise.resolve(actor);
   assert.deepStrictEqual(
     await bot.dispatchCreate(ctx2, {
+      identifier: "bot",
       id: "78acb1ea-4ac6-46b7-bcd4-3a8965d8126e",
     }),
     create,
   );
 
   await repository.addMessage(
+    "bot",
     "8386a4c7-06f8-409f-ad72-2bba43e83363",
     new Create({
       id: new URL(
@@ -932,11 +955,13 @@ test("BotImpl.dispatchCreate()", async () => {
   );
   assert.deepStrictEqual(
     await bot.dispatchCreate(ctx, {
+      identifier: "bot",
       id: "8386a4c7-06f8-409f-ad72-2bba43e83363",
     }),
     null,
   );
   const create2 = await bot.dispatchCreate(ctx2, {
+    identifier: "bot",
     id: "8386a4c7-06f8-409f-ad72-2bba43e83363",
   });
   assert.ok(create2 instanceof Create);
@@ -948,6 +973,7 @@ test("BotImpl.dispatchCreate()", async () => {
   );
 
   await repository.addMessage(
+    "bot",
     "ce8081ac-f238-484b-9a70-5d8a4b66d829",
     new Announce({
       id: new URL(
@@ -961,6 +987,7 @@ test("BotImpl.dispatchCreate()", async () => {
   );
   assert.deepStrictEqual(
     await bot.dispatchCreate(ctx, {
+      identifier: "bot",
       id: "ce8081ac-f238-484b-9a70-5d8a4b66d829",
     }),
     null,
@@ -984,6 +1011,7 @@ test("BotImpl.dispatchMessage()", async () => {
   );
 
   await repository.addMessage(
+    "bot",
     "78acb1ea-4ac6-46b7-bcd4-3a8965d8126e",
     new Create({
       id: new URL(
@@ -1039,6 +1067,7 @@ test("BotImpl.dispatchMessage()", async () => {
   );
 
   await repository.addMessage(
+    "bot",
     "8386a4c7-06f8-409f-ad72-2bba43e83363",
     new Create({
       id: new URL(
@@ -1074,6 +1103,7 @@ test("BotImpl.dispatchMessage()", async () => {
   );
 
   await repository.addMessage(
+    "bot",
     "ce8081ac-f238-484b-9a70-5d8a4b66d829",
     new Announce({
       id: new URL(
@@ -1107,11 +1137,12 @@ test("BotImpl.dispatchAnnounce()", async () => {
     undefined,
   );
   assert.deepStrictEqual(
-    await bot.dispatchAnnounce(ctx, { id: "non-existent" }),
+    await bot.dispatchAnnounce(ctx, { identifier: "bot", id: "non-existent" }),
     null,
   );
 
   await repository.addMessage(
+    "bot",
     "ce8081ac-f238-484b-9a70-5d8a4b66d829",
     new Announce({
       id: new URL(
@@ -1124,6 +1155,7 @@ test("BotImpl.dispatchAnnounce()", async () => {
     }),
   );
   const announce = await bot.dispatchAnnounce(ctx, {
+    identifier: "bot",
     id: "ce8081ac-f238-484b-9a70-5d8a4b66d829",
   });
   assert.ok(announce instanceof Announce);
@@ -1135,6 +1167,7 @@ test("BotImpl.dispatchAnnounce()", async () => {
   );
 
   await repository.addMessage(
+    "bot",
     "78acb1ea-4ac6-46b7-bcd4-3a8965d8126e",
     new Create({
       id: new URL(
@@ -1154,12 +1187,14 @@ test("BotImpl.dispatchAnnounce()", async () => {
   );
   assert.deepStrictEqual(
     await bot.dispatchAnnounce(ctx, {
+      identifier: "bot",
       id: "78acb1ea-4ac6-46b7-bcd4-3a8965d8126e",
     }),
     null,
   );
 
   await repository.addMessage(
+    "bot",
     "d4a7ef9b-682c-4de9-b23c-87747d6725cb",
     new Announce({
       id: new URL(
@@ -1172,6 +1207,7 @@ test("BotImpl.dispatchAnnounce()", async () => {
   );
   assert.deepStrictEqual(
     await bot.dispatchAnnounce(ctx, {
+      identifier: "bot",
       id: "d4a7ef9b-682c-4de9-b23c-87747d6725cb",
     }),
     null,
@@ -1185,6 +1221,7 @@ test("BotImpl.dispatchAnnounce()", async () => {
   });
   ctx2.getSignedKeyOwner = () => Promise.resolve(actor);
   const announce2 = await bot.dispatchAnnounce(ctx2, {
+    identifier: "bot",
     id: "d4a7ef9b-682c-4de9-b23c-87747d6725cb",
   });
   assert.ok(announce2 instanceof Announce);
@@ -1298,7 +1335,7 @@ for (const policy of ["accept", "reject", "manual"] as const) {
         object: new URL("https://example.com/ap/actor/bot"),
       });
       await bot.onFollowed(ctx, followWithoutActor);
-      assert.deepStrictEqual(await repository.countFollowers(), 0);
+      assert.deepStrictEqual(await repository.countFollowers("bot"), 0);
     });
 
     await t.test("with wrong actor", async () => {
@@ -1308,7 +1345,7 @@ for (const policy of ["accept", "reject", "manual"] as const) {
         object: new URL("https://example.com/ap/actor/bot"),
       });
       await bot.onFollowed(ctx, followWithWrongActor);
-      assert.deepStrictEqual(await repository.countFollowers(), 0);
+      assert.deepStrictEqual(await repository.countFollowers("bot"), 0);
     });
 
     const actor = new Person({
@@ -1323,7 +1360,7 @@ for (const policy of ["accept", "reject", "manual"] as const) {
         object: new URL("https://example.com/ap/actor/non-existent"),
       });
       await bot.onFollowed(ctx, followWithWrongRecipient);
-      assert.deepStrictEqual(await repository.countFollowers(), 0);
+      assert.deepStrictEqual(await repository.countFollowers("bot"), 0);
     });
 
     await t.test("with correct follow", async () => {
@@ -1334,14 +1371,15 @@ for (const policy of ["accept", "reject", "manual"] as const) {
       });
       await bot.onFollowed(ctx, follow);
       if (policy === "accept") {
-        assert.deepStrictEqual(await repository.countFollowers(), 1);
+        assert.deepStrictEqual(await repository.countFollowers("bot"), 1);
         assert.ok(
           await repository.hasFollower(
+            "bot",
             new URL("https://example.com/ap/actor/john"),
           ),
         );
         const [storedFollower] = await Array.fromAsync(
-          repository.getFollowers(),
+          repository.getFollowers("bot"),
         );
         assert.ok(storedFollower instanceof Person);
         assert.deepStrictEqual(storedFollower.id, actor.id);
@@ -1358,7 +1396,7 @@ for (const policy of ["accept", "reject", "manual"] as const) {
         assert.deepStrictEqual(ctx.forwardedRecipients, []);
         assert.deepStrictEqual(followRequests.length, 1);
       } else {
-        assert.deepStrictEqual(await repository.countFollowers(), 0);
+        assert.deepStrictEqual(await repository.countFollowers("bot"), 0);
         if (policy === "reject") {
           assert.deepStrictEqual(ctx.sentActivities.length, 1);
           const { activity, recipients } = ctx.sentActivities[0];
@@ -1396,6 +1434,7 @@ test("BotImpl.onUnfollowed()", async (t) => {
   const ctx = createMockInboxContext(bot, "https://example.com", "bot");
 
   await repository.addFollower(
+    "bot",
     new URL("https://example.com/ap/actor/john/follows/bot"),
     new Person({
       id: new URL("https://example.com/ap/actor/john"),
@@ -1404,8 +1443,8 @@ test("BotImpl.onUnfollowed()", async (t) => {
   );
 
   async function assertNoEffect() {
-    assert.deepStrictEqual(await repository.countFollowers(), 1);
-    const [follower] = await Array.fromAsync(repository.getFollowers());
+    assert.deepStrictEqual(await repository.countFollowers("bot"), 1);
+    const [follower] = await Array.fromAsync(repository.getFollowers("bot"));
     assert.ok(follower instanceof Person);
     assert.deepStrictEqual(
       follower.id,
@@ -1467,7 +1506,7 @@ test("BotImpl.onUnfollowed()", async (t) => {
       }),
     });
     await bot.onUnfollowed(ctx, undo);
-    assert.deepStrictEqual(await repository.countFollowers(), 0);
+    assert.deepStrictEqual(await repository.countFollowers("bot"), 0);
     assert.deepStrictEqual(ctx.sentActivities, []);
     assert.deepStrictEqual(ctx.forwardedRecipients, []);
     assert.deepStrictEqual(unfollowed.length, 1);
@@ -1528,6 +1567,7 @@ test("BotImpl.onFollowAccepted()", async (t) => {
 
   await t.test("with non-actor", async () => {
     await repository.addSentFollow(
+      "bot",
       "2ca58e2a-a34a-43e6-81af-c4f21ffed0c5",
       new Follow({
         id: new URL(
@@ -1551,6 +1591,7 @@ test("BotImpl.onFollowAccepted()", async (t) => {
 
   await t.test("with actor without URI", async () => {
     await repository.addSentFollow(
+      "bot",
       "a99ff3bf-72a2-412b-83b9-cba894d38805",
       new Follow({
         id: new URL(
@@ -1576,6 +1617,7 @@ test("BotImpl.onFollowAccepted()", async (t) => {
 
   await t.test("with actor", async () => {
     await repository.addSentFollow(
+      "bot",
       "3bca0b8e-503a-47ea-ad69-6b7c29369fbd",
       new Follow({
         id: new URL(
@@ -1607,6 +1649,7 @@ test("BotImpl.onFollowAccepted()", async (t) => {
       new URL("https://example.com/ap/actor/john"),
     );
     const follow = await repository.getFollowee(
+      "bot",
       new URL("https://example.com/ap/actor/john"),
     );
     assert.ok(follow != null);
@@ -1667,6 +1710,7 @@ test("BotImpl.onFollowRejected()", async (t) => {
 
   await t.test("with non-actor", async () => {
     await repository.addSentFollow(
+      "bot",
       "2ca58e2a-a34a-43e6-81af-c4f21ffed0c5",
       new Follow({
         id: new URL(
@@ -1690,6 +1734,7 @@ test("BotImpl.onFollowRejected()", async (t) => {
 
   await t.test("with actor without URI", async () => {
     await repository.addSentFollow(
+      "bot",
       "a99ff3bf-72a2-412b-83b9-cba894d38805",
       new Follow({
         id: new URL(
@@ -1715,6 +1760,7 @@ test("BotImpl.onFollowRejected()", async (t) => {
 
   await t.test("with actor", async () => {
     await repository.addSentFollow(
+      "bot",
       "3bca0b8e-503a-47ea-ad69-6b7c29369fbd",
       new Follow({
         id: new URL(
@@ -1746,7 +1792,10 @@ test("BotImpl.onFollowRejected()", async (t) => {
       new URL("https://example.com/ap/actor/john"),
     );
     assert.deepStrictEqual(
-      await repository.getSentFollow("3bca0b8e-503a-47ea-ad69-6b7c29369fbd"),
+      await repository.getSentFollow(
+        "bot",
+        "3bca0b8e-503a-47ea-ad69-6b7c29369fbd",
+      ),
       undefined,
     );
   });
@@ -1793,6 +1842,7 @@ test("BotImpl.onCreated()", async (t) => {
   });
 
   await repository.addMessage(
+    "bot",
     "a6358f1b-c978-49d3-8065-37a1df6168de",
     new Create({
       id: new URL(
@@ -2016,7 +2066,7 @@ test("BotImpl.onAnnounced()", async () => {
     to: PUBLIC_COLLECTION,
     cc: new URL("https://example.com/ap/actor/bot/followers"),
     object: new Note({
-      id: new URL("https://example.com/ap/actor/bot/note/1"),
+      id: new URL("https://example.com/notes/1"),
       attribution: new URL("https://example.com/ap/actor/bot"),
       to: PUBLIC_COLLECTION,
       cc: new URL("https://example.com/ap/actor/bot/followers"),
@@ -2049,7 +2099,7 @@ test("BotImpl.onLiked()", async () => {
     id: new URL("https://example.com/ap/actor/bot/like/1"),
     actor: new URL("https://example.com/ap/actor/bot"),
     object: new Note({
-      id: new URL("https://example.com/ap/actor/bot/note/1"),
+      id: new URL("https://example.com/notes/1"),
       attribution: new URL("https://example.com/ap/actor/bot"),
       to: PUBLIC_COLLECTION,
       cc: new URL("https://example.com/ap/actor/bot/followers"),
@@ -2081,7 +2131,7 @@ test("BotImpl.onUnliked()", async () => {
     id: new URL("https://example.com/ap/actor/bot/like/1"),
     actor: new URL("https://example.com/ap/actor/bot"),
     object: new Note({
-      id: new URL("https://example.com/ap/actor/bot/note/1"),
+      id: new URL("https://example.com/notes/1"),
       attribution: new URL("https://example.com/ap/actor/bot"),
       to: PUBLIC_COLLECTION,
       cc: new URL("https://example.com/ap/actor/bot/followers"),
@@ -2129,7 +2179,7 @@ test("BotImpl.onReacted()", async () => {
     actor: new URL("https://example.com/ap/actor/bot"),
     name: ":heart:",
     object: new Note({
-      id: new URL("https://example.com/ap/actor/bot/note/1"),
+      id: new URL("https://example.com/notes/1"),
       attribution: new URL("https://example.com/ap/actor/bot"),
       to: PUBLIC_COLLECTION,
       cc: new URL("https://example.com/ap/actor/bot/followers"),
@@ -2168,7 +2218,7 @@ test("BotImpl.onReacted()", async () => {
     actor: new URL("https://example.com/ap/actor/bot"),
     name: ":thumbsup:",
     object: new Note({
-      id: new URL("https://example.com/ap/actor/bot/note/1"),
+      id: new URL("https://example.com/notes/1"),
       attribution: new URL("https://example.com/ap/actor/bot"),
       to: PUBLIC_COLLECTION,
       cc: new URL("https://example.com/ap/actor/bot/followers"),
@@ -2217,7 +2267,7 @@ test("BotImpl.onUnreacted()", async () => {
     actor: new URL("https://example.com/ap/actor/bot"),
     name: ":heart:",
     object: new Note({
-      id: new URL("https://example.com/ap/actor/bot/note/1"),
+      id: new URL("https://example.com/notes/1"),
       attribution: new URL("https://example.com/ap/actor/bot"),
       to: PUBLIC_COLLECTION,
       cc: new URL("https://example.com/ap/actor/bot/followers"),
@@ -2262,7 +2312,7 @@ test("BotImpl.onUnreacted()", async () => {
     actor: new URL("https://example.com/ap/actor/bot"),
     name: ":thumbsup:",
     object: new Note({
-      id: new URL("https://example.com/ap/actor/bot/note/1"),
+      id: new URL("https://example.com/notes/1"),
       attribution: new URL("https://example.com/ap/actor/bot"),
       to: PUBLIC_COLLECTION,
       cc: new URL("https://example.com/ap/actor/bot/followers"),
@@ -2394,6 +2444,7 @@ test("BotImpl.fetch() includes FEP-5711 inverse properties", async () => {
   const actorId = new URL("https://example.com/ap/actor/bot");
 
   await repository.addFollower(
+    "bot",
     new URL("https://example.com/actor/1#follow"),
     new Person({
       id: new URL("https://example.com/actor/1"),
@@ -2402,6 +2453,7 @@ test("BotImpl.fetch() includes FEP-5711 inverse properties", async () => {
     }),
   );
   await repository.addMessage(
+    "bot",
     "78acb1ea-4ac6-46b7-bcd4-3a8965d8126e",
     new Create({
       id: new URL(
@@ -2766,7 +2818,7 @@ test("BotImpl.onVote()", async (t) => {
     }),
     published: Temporal.Now.instant(),
   });
-  await repository.addMessage(pollId, poll);
+  await repository.addMessage("bot", pollId, poll);
 
   // Create a voter
   const voter = new Person({
@@ -2824,7 +2876,7 @@ test("BotImpl.onVote()", async (t) => {
     );
 
     // Check that vote count was updated in repository
-    const updatedPoll = await repository.getMessage(pollId);
+    const updatedPoll = await repository.getMessage("bot", pollId);
     assert.ok(updatedPoll instanceof Create);
     const updatedQuestion = await updatedPoll.getObject(ctx);
     assert.ok(updatedQuestion instanceof Question);
@@ -2873,7 +2925,7 @@ test("BotImpl.onVote()", async (t) => {
       }),
       published: Temporal.Now.instant(),
     });
-    await repository.addMessage(multiPollId, multiPoll);
+    await repository.addMessage("bot", multiPollId, multiPoll);
 
     ctx.sentActivities = [];
     ctx.forwardedRecipients = [];
@@ -2967,7 +3019,7 @@ test("BotImpl.onVote()", async (t) => {
       }),
       published: Temporal.Now.instant(),
     });
-    await repository.addMessage(expiredPollId, expiredPoll);
+    await repository.addMessage("bot", expiredPollId, expiredPoll);
 
     ctx.sentActivities = [];
     ctx.forwardedRecipients = [];
@@ -3034,3 +3086,160 @@ test("BotImpl.onVote()", async (t) => {
 });
 
 // cSpell: ignore thumbsup
+
+test("BotImpl.fetch() redirects legacy object URIs", async (t) => {
+  const bot = new BotImpl<void>({
+    kv: new MemoryKvStore(),
+    username: "bot",
+  });
+
+  await t.test("redirects GET requests", async () => {
+    const response = await bot.fetch(
+      new Request(
+        "https://example.com/ap/follow/2ca58e2a-a34a-43e6-81af-c4f21ffed0c5",
+      ),
+      undefined,
+    );
+    assert.deepStrictEqual(response.status, 301);
+    assert.deepStrictEqual(
+      response.headers.get("Location"),
+      "https://example.com/ap/actor/bot/follow/2ca58e2a-a34a-43e6-81af-c4f21ffed0c5",
+    );
+  });
+
+  await t.test("redirects HEAD requests", async () => {
+    const response = await bot.fetch(
+      new Request("https://example.com/ap/note/123", { method: "HEAD" }),
+      undefined,
+    );
+    assert.deepStrictEqual(response.status, 301);
+    assert.deepStrictEqual(
+      response.headers.get("Location"),
+      "https://example.com/ap/actor/bot/note/123",
+    );
+  });
+
+  await t.test("preserves the query string", async () => {
+    const response = await bot.fetch(
+      new Request("https://example.com/ap/note/123?foo=bar"),
+      undefined,
+    );
+    assert.deepStrictEqual(response.status, 301);
+    assert.deepStrictEqual(
+      response.headers.get("Location"),
+      "https://example.com/ap/actor/bot/note/123?foo=bar",
+    );
+  });
+
+  await t.test("does not redirect POST requests", async () => {
+    const response = await bot.fetch(
+      new Request("https://example.com/ap/note/123", { method: "POST" }),
+      undefined,
+    );
+    assert.notDeepStrictEqual(response.status, 301);
+  });
+
+  await t.test("does not redirect canonical or unrelated paths", async () => {
+    const canonical = await bot.fetch(
+      new Request("https://example.com/ap/actor/bot/note/123"),
+      undefined,
+    );
+    assert.notDeepStrictEqual(canonical.status, 301);
+    const inbox = await bot.fetch(
+      new Request("https://example.com/ap/inbox"),
+      undefined,
+    );
+    assert.notDeepStrictEqual(inbox.status, 301);
+  });
+});
+
+test("BotImpl.onFollowAccepted() with canonical follow URIs", async () => {
+  const repository = new MemoryRepository();
+  const bot = new BotImpl<void>({
+    kv: new MemoryKvStore(),
+    repository,
+    username: "bot",
+  });
+  const accepted: Actor[] = [];
+  bot.onAcceptFollow = (_, actor) => void (accepted.push(actor));
+  const ctx = createMockInboxContext(bot, "https://example.com", "bot");
+  await repository.addSentFollow(
+    "bot",
+    "9d952a10-77e6-46bd-a48a-208b47e5e2bb",
+    new Follow({
+      id: new URL(
+        "https://example.com/ap/actor/bot/follow/9d952a10-77e6-46bd-a48a-208b47e5e2bb",
+      ),
+      actor: new URL("https://example.com/ap/actor/bot"),
+      object: new Person({
+        id: new URL("https://example.com/ap/actor/john"),
+        preferredUsername: "john",
+      }),
+    }),
+  );
+  await bot.onFollowAccepted(
+    ctx,
+    new Accept({
+      actor: new URL("https://example.com/ap/actor/john"),
+      object: new URL(
+        "https://example.com/ap/actor/bot/follow/9d952a10-77e6-46bd-a48a-208b47e5e2bb",
+      ),
+    }),
+  );
+  assert.deepStrictEqual(accepted.length, 1);
+  assert.deepStrictEqual(
+    accepted[0].id,
+    new URL("https://example.com/ap/actor/john"),
+  );
+  assert.ok(
+    await repository.getFollowee(
+      "bot",
+      new URL("https://example.com/ap/actor/john"),
+    ) != null,
+  );
+});
+
+test("BotImpl.onLiked() with legacy message URIs", async () => {
+  const repository = new MemoryRepository();
+  const bot = new BotImpl<void>({
+    kv: new MemoryKvStore(),
+    repository,
+    username: "bot",
+  });
+  const likes: Like<void>[] = [];
+  bot.onLike = (_, like) => void (likes.push(like));
+  const ctx = createMockInboxContext(bot, "https://example.com", "bot");
+  const messageId = "01941f29-7c00-7fe8-ab0a-7b593990a3c0";
+  // The message is stored with a canonical URI, but a remote server that
+  // saw it before the upgrade may still refer to it by its legacy URI:
+  await repository.addMessage(
+    "bot",
+    messageId,
+    new Create({
+      id: new URL(
+        `https://example.com/ap/actor/bot/create/${messageId}`,
+      ),
+      actor: new URL("https://example.com/ap/actor/bot"),
+      to: PUBLIC_COLLECTION,
+      object: new Note({
+        id: new URL(`https://example.com/ap/actor/bot/note/${messageId}`),
+        attribution: new URL("https://example.com/ap/actor/bot"),
+        to: PUBLIC_COLLECTION,
+        content: "Hello, world!",
+      }),
+    }),
+  );
+  await bot.onLiked(
+    ctx,
+    new RawLike({
+      id: new URL("https://remote.example/likes/1"),
+      actor: new URL("https://example.com/ap/actor/bot"),
+      object: new URL(`https://example.com/ap/note/${messageId}`),
+    }),
+  );
+  assert.deepStrictEqual(likes.length, 1);
+  assert.deepStrictEqual(
+    likes[0].message.id,
+    new URL(`https://example.com/ap/actor/bot/note/${messageId}`),
+  );
+});
diff --git a/packages/botkit/src/bot-impl.ts b/packages/botkit/src/bot-impl.ts
index 1b16dcf..0914fda 100644
--- a/packages/botkit/src/bot-impl.ts
+++ b/packages/botkit/src/bot-impl.ts
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 import {
   type Context,
-  createFederation,
   type Federation,
   generateCryptoKeyPair,
   type InboxContext,
@@ -26,7 +25,7 @@ import {
   type UnverifiedActivityReason,
 } from "@fedify/fedify";
 import {
-  Accept,
+  type Accept,
   type Activity,
   type Actor,
   Announce,
@@ -34,7 +33,6 @@ import {
   Article,
   ChatMessage,
   Create,
-  Delete,
   Emoji as APEmoji,
   EmojiReact,
   Endpoints,
@@ -50,17 +48,18 @@ import {
   PUBLIC_COLLECTION,
   Question,
   type Recipient,
-  Reject,
+  type Reject,
   Service,
-  Undo,
+  type Undo,
   Update,
 } from "@fedify/vocab";
-import { getLogger } from "@logtape/logtape";
-import mimeDb from "mime-db";
-import fs from "node:fs/promises";
-import { getXForwardedRequest } from "x-forwarded-fetch";
-import metadata from "../deno.json" with { type: "json" };
 import type { Bot, CreateBotOptions, PagesOptions } from "./bot.ts";
+import type {
+  BotDispatcher,
+  BotGroup,
+  BotProfile,
+  CreateBotGroupOptions,
+} from "./instance.ts";
 import {
   type CustomEmoji,
   type DeferredCustomEmoji,
@@ -84,6 +83,7 @@ import type {
   VoteEventHandler,
 } from "./events.ts";
 import { FollowRequestImpl } from "./follow-impl.ts";
+import { InstanceImpl } from "./instance-impl.ts";
 import {
   createMessage,
   getMessageVisibility,
@@ -92,10 +92,17 @@ import {
   messageClasses,
 } from "./message-impl.ts";
 import type { Message, MessageClass, SharedMessage } from "./message.ts";
-import { app } from "./pages.tsx";
 import type { Vote } from "./poll.ts";
 import type { Like, Reaction } from "./reaction.ts";
-import { KvRepository, type Repository, type Uuid } from "./repository.ts";
+import {
+  ActorScopedRepository,
+  KvRepository,
+  type Repository,
+  type RepositoryGetFollowersOptions,
+  type RepositoryGetMessagesOptions,
+  type Uuid,
+} from "./repository.ts";
+import { parseLocalUri } from "./uri.ts";
 import { SessionImpl } from "./session-impl.ts";
 import type { Session } from "./session.ts";
 import type { Text } from "./text.ts";
@@ -103,8 +110,42 @@ import type { Text } from "./text.ts";
 export interface BotImplOptions<TContextData>
   extends CreateBotOptions<TContextData> {
   collectionWindow?: number;
+
+  /**
+   * The instance to host the bot on.  If omitted, a dedicated instance is
+   * created from the given options, which preserves the single-bot behavior
+   * of BotKit 0.4 and earlier.
+   */
+  instance?: InstanceImpl<TContextData>;
+
+  /**
+   * Whether the bot is a transient view of a dynamically resolved bot,
+   * which is not registered on the instance.
+   */
+  transient?: boolean;
 }
 
+/**
+ * The names of the event handler properties of {@link BotEventHandlers}.
+ * @internal
+ */
+export const botEventHandlerNames = [
+  "onFollow",
+  "onUnfollow",
+  "onAcceptFollow",
+  "onRejectFollow",
+  "onMention",
+  "onReply",
+  "onQuote",
+  "onMessage",
+  "onSharedMessage",
+  "onLike",
+  "onUnlike",
+  "onReact",
+  "onUnreact",
+  "onVote",
+] as const;
+
 export class BotImpl<TContextData> implements Bot<TContextData> {
   readonly identifier: string;
   readonly class: typeof Service | typeof Application;
@@ -117,13 +158,48 @@ export class BotImpl<TContextData> implements Bot<TContextData> {
   readonly properties: Record<string, Text<"block" | "inline", TContextData>>;
   #properties: { pairs: PropertyValue[]; tags: (Link | Object)[] } | null;
   readonly followerPolicy: "accept" | "reject" | "manual";
-  readonly customEmojis: Record<string, CustomEmoji>;
-  readonly repository: Repository;
-  readonly software?: Software;
-  readonly behindProxy: boolean;
-  readonly pages: Required<PagesOptions>;
-  readonly collectionWindow: number;
-  readonly federation: Federation<TContextData>;
+  readonly repository: ActorScopedRepository;
+
+  /**
+   * The instance hosting the bot.  It owns the shared infrastructure:
+   * the Fedify federation, the key–value store, the message queue,
+   * the root repository, and HTTP handling.
+   */
+  readonly instance: InstanceImpl<TContextData>;
+
+  get customEmojis(): Record<string, CustomEmoji> {
+    return this.instance.customEmojis;
+  }
+
+  get software(): Software | undefined {
+    return this.instance.software;
+  }
+
+  get behindProxy(): boolean {
+    return this.instance.behindProxy;
+  }
+
+  get pages(): Required<PagesOptions> {
+    return this.instance.pages;
+  }
+
+  get collectionWindow(): number {
+    return this.instance.collectionWindow;
+  }
+
+  get federation(): Federation<TContextData> {
+    return this.instance.federation;
+  }
+
+  /**
+   * The identifier of the bot actor that owns local objects whose URIs are
+   * in the legacy (pre-0.5) format, which did not carry the identifier.
+   * Legacy URIs can only occur in deployments that hosted a single bot
+   * before the upgrade, so they are attributed to that bot.
+   */
+  get legacyObjectUrisIdentifier(): string | undefined {
+    return this.instance.legacyObjectUrisIdentifier;
+  }
 
   onFollow?: FollowEventHandler<TContextData>;
   onUnfollow?: UnfollowEventHandler<TContextData>;
@@ -152,118 +228,27 @@ export class BotImpl<TContextData> implements Bot<TContextData> {
     this.properties = options.properties ?? {};
     this.#properties = null;
     this.followerPolicy = options.followerPolicy ?? "accept";
-    this.customEmojis = {};
-    this.repository = options.repository ?? new KvRepository(options.kv);
-    this.software = options.software;
-    this.pages = {
-      color: "green",
-      css: "",
-      ...(options.pages ?? {}),
-    };
-    this.federation = createFederation<TContextData>({
+    this.instance = options.instance ?? new InstanceImpl({
       kv: options.kv,
+      // The single-bot deployment may carry data from BotKit 0.4 or
+      // earlier; adopt it for this bot before the first repository
+      // operation:
+      repository: new MigrationGatedRepository(
+        options.repository ?? new KvRepository(options.kv),
+        this.identifier,
+      ),
       queue: options.queue,
-      userAgent: {
-        software: `BotKit/${metadata.version}`,
-      },
+      software: options.software,
+      behindProxy: options.behindProxy,
+      pages: options.pages,
+      collectionWindow: options.collectionWindow,
+      // A dedicated instance hosts the single bot that predates the
+      // multi-bot upgrade, so legacy object URIs belong to it:
+      legacyObjectUris: { identifier: this.identifier },
+      compatMode: true,
     });
-    this.behindProxy = options.behindProxy ?? false;
-    this.collectionWindow = options.collectionWindow ?? 50;
-    this.initialize();
-  }
-
-  initialize(): void {
-    this.federation
-      .setActorDispatcher(
-        "/ap/actor/{identifier}",
-        this.dispatchActor.bind(this),
-      )
-      .mapHandle(this.mapHandle.bind(this))
-      .setKeyPairsDispatcher(this.dispatchActorKeyPairs.bind(this));
-    this.federation
-      .setFollowersDispatcher(
-        "/ap/actor/{identifier}/followers",
-        this.dispatchFollowers.bind(this),
-      )
-      .setFirstCursor(this.getFollowersFirstCursor.bind(this))
-      .setCounter(this.countFollowers.bind(this));
-    this.federation
-      .setOutboxDispatcher(
-        "/ap/actor/{identifier}/outbox",
-        this.dispatchOutbox.bind(this),
-      )
-      .setFirstCursor(this.getOutboxFirstCursor.bind(this))
-      .setCounter(this.countOutbox.bind(this));
-    this.federation
-      .setObjectDispatcher(
-        Follow,
-        "/ap/follow/{id}",
-        this.dispatchFollow.bind(this),
-      )
-      .authorize(this.authorizeFollow.bind(this));
-    this.federation.setObjectDispatcher(
-      Create,
-      "/ap/create/{id}",
-      this.dispatchCreate.bind(this),
-    );
-    this.federation.setObjectDispatcher(
-      Article,
-      "/ap/article/{id}",
-      (ctx, values) => this.dispatchMessage(Article, ctx, values.id),
-    );
-    this.federation.setObjectDispatcher(
-      ChatMessage,
-      "/ap/chat-message/{id}",
-      (ctx, values) => this.dispatchMessage(ChatMessage, ctx, values.id),
-    );
-    this.federation.setObjectDispatcher(
-      Note,
-      "/ap/note/{id}",
-      (ctx, values) => this.dispatchMessage(Note, ctx, values.id),
-    );
-    this.federation.setObjectDispatcher(
-      Question,
-      "/ap/question/{id}",
-      (ctx, values) => this.dispatchMessage(Question, ctx, values.id),
-    );
-    this.federation.setObjectDispatcher(
-      Announce,
-      "/ap/announce/{id}",
-      this.dispatchAnnounce.bind(this),
-    );
-    this.federation.setObjectDispatcher(
-      APEmoji,
-      "/ap/emoji/{name}",
-      this.dispatchEmoji.bind(this),
-    );
-    this.federation
-      .setInboxListeners("/ap/actor/{identifier}/inbox", "/ap/inbox")
-      .onUnverifiedActivity(this.onUnverifiedActivity.bind(this))
-      .on(Follow, this.onFollowed.bind(this))
-      .on(Undo, async (ctx, undo) => {
-        const object = await undo.getObject(ctx);
-        if (object instanceof Follow) await this.onUnfollowed(ctx, undo);
-        else if (object instanceof RawLike) await this.onUnliked(ctx, undo);
-        else {
-          const logger = getLogger(["botkit", "bot", "inbox"]);
-          logger.warn(
-            "The Undo object {undoId} is not about Follow or Like: {object}.",
-            { undoId: undo.id?.href, object },
-          );
-        }
-      })
-      .on(Accept, this.onFollowAccepted.bind(this))
-      .on(Reject, this.onFollowRejected.bind(this))
-      .on(Create, this.onCreated.bind(this))
-      .on(Announce, this.onAnnounced.bind(this))
-      .on(RawLike, this.onLiked.bind(this))
-      .setSharedKeyDispatcher(this.dispatchSharedKey.bind(this));
-    if (this.software != null) {
-      this.federation.setNodeInfoDispatcher(
-        "/nodeinfo/2.1",
-        this.dispatchNodeInfo.bind(this),
-      );
-    }
+    this.repository = this.instance.repository.forIdentifier(this.identifier);
+    if (!options.transient) this.instance.addBot(this);
   }
 
   async getActorSummary(
@@ -346,7 +331,7 @@ export class BotImpl<TContextData> implements Bot<TContextData> {
       outbox: ctx.getOutboxUri(identifier),
       publicKey: keyPairs[0].cryptographicKey,
       assertionMethods: keyPairs.map((pair) => pair.multikey),
-      url: new URL("/", ctx.origin),
+      url: this.instance.getBotWebUrl(this, ctx.origin),
     });
   }
 
@@ -484,8 +469,9 @@ export class BotImpl<TContextData> implements Bot<TContextData> {
 
   async dispatchFollow(
     _ctx: RequestContext<TContextData>,
-    values: { id: string },
+    values: { identifier: string; id: string },
   ): Promise<Follow | null> {
+    if (values.identifier !== this.identifier) return null;
     const id = values.id as Uuid;
     const follow = await this.repository.getSentFollow(id);
     return follow ?? null;
@@ -493,8 +479,9 @@ export class BotImpl<TContextData> implements Bot<TContextData> {
 
   async authorizeFollow(
     ctx: RequestContext<TContextData>,
-    values: { id: string },
+    values: { identifier: string; id: string },
   ): Promise<boolean> {
+    if (values.identifier !== this.identifier) return false;
     const signedKeyOwner = await ctx.getSignedKeyOwner();
     if (signedKeyOwner == null || signedKeyOwner.id == null) return false;
     const id = values.id as Uuid;
@@ -506,8 +493,9 @@ export class BotImpl<TContextData> implements Bot<TContextData> {
 
   async dispatchCreate(
     ctx: RequestContext<TContextData>,
-    values: { id: string },
+    values: { identifier: string; id: string },
   ): Promise<Create | null> {
+    if (values.identifier !== this.identifier) return null;
     const activity = await this.repository.getMessage(values.id as Uuid);
     if (!(activity instanceof Create)) return null;
     const isVisible = await this.getPermissionChecker(ctx);
@@ -534,8 +522,9 @@ export class BotImpl<TContextData> implements Bot<TContextData> {
 
   async dispatchAnnounce(
     ctx: RequestContext<TContextData>,
-    values: { id: string },
+    values: { identifier: string; id: string },
   ): Promise<Announce | null> {
+    if (values.identifier !== this.identifier) return null;
     const activity = await this.repository.getMessage(values.id as Uuid);
     if (!(activity instanceof Announce)) return null;
     const isVisible = await this.getPermissionChecker(ctx);
@@ -546,28 +535,19 @@ export class BotImpl<TContextData> implements Bot<TContextData> {
     ctx: Context<TContextData>,
     values: { name: string },
   ): APEmoji | null {
-    const customEmoji = this.customEmojis[values.name];
-    if (customEmoji == null) return null;
-    return this.getEmoji(ctx, values.name, customEmoji);
+    return this.instance.dispatchEmoji(ctx, values);
   }
 
-  dispatchSharedKey(_ctx: Context<TContextData>): { identifier: string } {
-    return { identifier: this.identifier };
+  dispatchSharedKey(ctx: Context<TContextData>): { identifier: string } {
+    return this.instance.dispatchSharedKey(ctx);
   }
 
   onUnverifiedActivity(
-    _ctx: RequestContext<TContextData>,
+    ctx: RequestContext<TContextData>,
     activity: Activity,
     reason: UnverifiedActivityReason,
   ): Response | void {
-    if (
-      activity instanceof Delete &&
-      reason.type === "keyFetchError" &&
-      "status" in reason.result &&
-      reason.result.status === 410
-    ) {
-      return new Response(null, { status: 202 });
-    }
+    return this.instance.onUnverifiedActivity(ctx, activity, reason);
   }
 
   async onFollowed(
@@ -620,8 +600,17 @@ export class BotImpl<TContextData> implements Bot<TContextData> {
     ctx: InboxContext<TContextData>,
     accept: Accept,
   ): Promise<void> {
-    const parsedObj = ctx.parseUri(accept.objectId);
-    if (parsedObj?.type !== "object" || parsedObj.class !== Follow) return;
+    const parsedObj = parseLocalUri(
+      ctx,
+      accept.objectId,
+      this.legacyObjectUrisIdentifier,
+    );
+    if (
+      parsedObj?.type !== "object" || parsedObj.class !== Follow ||
+      parsedObj.values.identifier !== this.identifier
+    ) {
+      return;
+    }
     const follow = await this.repository.getSentFollow(
       parsedObj.values.id as Uuid,
     );
@@ -644,8 +633,17 @@ export class BotImpl<TContextData> implements Bot<TContextData> {
     ctx: InboxContext<TContextData>,
     reject: Reject,
   ): Promise<void> {
-    const parsedObj = ctx.parseUri(reject.objectId);
-    if (parsedObj?.type !== "object" || parsedObj.class !== Follow) return;
+    const parsedObj = parseLocalUri(
+      ctx,
+      reject.objectId,
+      this.legacyObjectUrisIdentifier,
+    );
+    if (
+      parsedObj?.type !== "object" || parsedObj.class !== Follow ||
+      parsedObj.values.identifier !== this.identifier
+    ) {
+      return;
+    }
     const id = parsedObj.values.id as Uuid;
     const follow = await this.repository.getSentFollow(id);
     if (follow == null) return;
@@ -681,12 +679,17 @@ export class BotImpl<TContextData> implements Bot<TContextData> {
       if (messageCache != null) return messageCache;
       return messageCache = await createMessage(object, session, {});
     };
-    const replyTarget = ctx.parseUri(object.replyTargetId);
+    const replyTarget = parseLocalUri(
+      ctx,
+      object.replyTargetId,
+      this.legacyObjectUrisIdentifier,
+    );
     if (
       this.onVote != null &&
       object instanceof Note && replyTarget?.type === "object" &&
       // @ts-ignore: replyTarget.class satisfies (typeof messageClasses)[number]
       messageClasses.includes(replyTarget.class) &&
+      replyTarget.values.identifier === this.identifier &&
       object.name != null
     ) {
       if (
@@ -810,7 +813,8 @@ export class BotImpl<TContextData> implements Bot<TContextData> {
       this.onReply != null &&
       replyTarget?.type === "object" &&
       // @ts-ignore: replyTarget.class satisfies (typeof messageClasses)[number]
-      messageClasses.includes(replyTarget.class)
+      messageClasses.includes(replyTarget.class) &&
+      replyTarget.values.identifier === this.identifier
     ) {
       const message = await getMessage();
       if (
@@ -833,12 +837,17 @@ export class BotImpl<TContextData> implements Bot<TContextData> {
       }
     }
     if (quoteUrl == null) quoteUrl = object.quoteUrl;
-    const quoteTarget = ctx.parseUri(quoteUrl);
+    const quoteTarget = parseLocalUri(
+      ctx,
+      quoteUrl,
+      this.legacyObjectUrisIdentifier,
+    );
     if (
       this.onQuote != null &&
       quoteTarget?.type === "object" &&
       // @ts-ignore: quoteTarget.class satisfies (typeof messageClasses)[number]
-      messageClasses.includes(quoteTarget.class)
+      messageClasses.includes(quoteTarget.class) &&
+      quoteTarget.values.identifier === this.identifier
     ) {
       const message = await getMessage();
       if (
@@ -878,12 +887,17 @@ export class BotImpl<TContextData> implements Bot<TContextData> {
       this.onSharedMessage == null || announce.id == null ||
       announce.actorId == null
     ) return;
-    const objectUri = ctx.parseUri(announce.objectId);
+    const objectUri = parseLocalUri(
+      ctx,
+      announce.objectId,
+      this.legacyObjectUrisIdentifier,
+    );
     let object: Object | null = null;
     if (
       objectUri?.type === "object" &&
       // deno-lint-ignore no-explicit-any
-      messageClasses.includes(objectUri.class as any)
+      messageClasses.includes(objectUri.class as any) &&
+      objectUri.values.identifier === this.identifier
     ) {
       const msg = await this.repository.getMessage(objectUri.values.id as Uuid);
       if (msg instanceof Create) object = await msg.getObject(ctx);
@@ -914,13 +928,20 @@ export class BotImpl<TContextData> implements Bot<TContextData> {
     { session: Session<TContextData>; like: Like<TContextData> } | undefined
   > {
     if (like.id == null || like.actorId == null) return undefined;
-    const objectUri = ctx.parseUri(like.objectId);
+    const objectUri = parseLocalUri(
+      ctx,
+      like.objectId,
+      this.legacyObjectUrisIdentifier,
+    );
     let object: Object | null = null;
     if (
       objectUri?.type === "object" &&
       // deno-lint-ignore no-explicit-any
       messageClasses.includes(objectUri.class as any)
     ) {
+      // A local object owned by another bot is not this bot's to report;
+      // the owner receives the activity through its own routing:
+      if (objectUri.values.identifier !== this.identifier) return undefined;
       const msg = await this.repository.getMessage(objectUri.values.id as Uuid);
       if (msg instanceof Create) object = await msg.getObject(ctx);
     } else {
@@ -990,13 +1011,20 @@ export class BotImpl<TContextData> implements Bot<TContextData> {
       }
     }
     if (emoji == null) return undefined;
-    const objectUri = ctx.parseUri(react.objectId);
+    const objectUri = parseLocalUri(
+      ctx,
+      react.objectId,
+      this.legacyObjectUrisIdentifier,
+    );
     let object: Object | null = null;
     if (
       objectUri?.type === "object" &&
       // deno-lint-ignore no-explicit-any
       messageClasses.includes(objectUri.class as any)
     ) {
+      // A local object owned by another bot is not this bot's to report;
+      // the owner receives the activity through its own routing:
+      if (objectUri.values.identifier !== this.identifier) return undefined;
       const msg = await this.repository.getMessage(objectUri.values.id as Uuid);
       if (msg instanceof Create) object = await msg.getObject(ctx);
     } else {
@@ -1046,23 +1074,8 @@ export class BotImpl<TContextData> implements Bot<TContextData> {
     await this.onUnreact(session, reaction);
   }
 
-  dispatchNodeInfo(_ctx: Context<TContextData>): NodeInfo {
-    return {
-      software: this.software!,
-      protocols: ["activitypub"],
-      services: {
-        outbound: ["atom1.0"], // TODO
-      },
-      usage: {
-        users: {
-          total: 1,
-          activeMonth: 1, // FIXME
-          activeHalfyear: 1, // FIXME
-        },
-        localPosts: 0, // FIXME
-        localComments: 0,
-      },
-    };
+  dispatchNodeInfo(ctx: Context<TContextData>): NodeInfo {
+    return this.instance.dispatchNodeInfo(ctx);
   }
 
   getSession(
@@ -1082,106 +1095,20 @@ export class BotImpl<TContextData> implements Bot<TContextData> {
     return new SessionImpl(this, ctx);
   }
 
-  async addCollectionInverseProperty(
+  addCollectionInverseProperty(
     request: Request,
     contextData: TContextData,
     response: Response,
   ): Promise<Response> {
-    if (!response.ok) return response;
-    const ctx = this.federation.createContext(request, contextData);
-    const parsed = ctx.parseUri(new URL(request.url));
-    if (
-      parsed == null ||
-      (parsed.type !== "outbox" && parsed.type !== "followers") ||
-      parsed.identifier == null
-    ) {
-      return response;
-    }
-    const contentType = response.headers.get("Content-Type");
-    if (
-      contentType == null ||
-      (
-        !contentType.startsWith("application/activity+json") &&
-        !contentType.startsWith("application/ld+json")
-      )
-    ) {
-      return response;
-    }
-    const body = await response.json();
-    if (typeof body !== "object" || body == null || Array.isArray(body)) {
-      return new Response(JSON.stringify(body), {
-        headers: response.headers,
-        status: response.status,
-        statusText: response.statusText,
-      });
-    }
-    const property = parsed.type === "outbox" ? "outboxOf" : "followersOf";
-    const actorUri = ctx.getActorUri(parsed.identifier).href;
-    if (body[property] === actorUri) {
-      return new Response(JSON.stringify(body), {
-        headers: response.headers,
-        status: response.status,
-        statusText: response.statusText,
-      });
-    }
-    const headers = new Headers(response.headers);
-    headers.delete("Content-Length");
-    return new Response(JSON.stringify({ ...body, [property]: actorUri }), {
-      headers,
-      status: response.status,
-      statusText: response.statusText,
-    });
+    return this.instance.addCollectionInverseProperty(
+      request,
+      contextData,
+      response,
+    );
   }
 
-  async fetch(request: Request, contextData: TContextData): Promise<Response> {
-    if (this.behindProxy) {
-      request = await getXForwardedRequest(request);
-    }
-    const url = new URL(request.url);
-    if (
-      url.pathname.startsWith("/.well-known/") ||
-      url.pathname.startsWith("/ap/") ||
-      url.pathname.startsWith("/nodeinfo/")
-    ) {
-      const response = await this.federation.fetch(request, { contextData });
-      return await this.addCollectionInverseProperty(
-        request,
-        contextData,
-        response,
-      );
-    }
-    const match = /^\/emojis\/([a-z0-9-_]+)(?:$|\.)/.exec(url.pathname);
-    if (match != null) {
-      const customEmoji = this.customEmojis[match[1]];
-      if (customEmoji == null || !("file" in customEmoji)) {
-        return new Response("Not Found", { status: 404 });
-      }
-      let file: fs.FileHandle;
-      try {
-        file = await fs.open(customEmoji.file, "r");
-      } catch (error) {
-        if (
-          typeof error === "object" && error != null && "code" in error &&
-          error.code === "ENOENT"
-        ) {
-          return new Response("Not Found", { status: 404 });
-        }
-        throw error;
-      }
-      const fileInfo = await file.stat();
-      return new Response(file.readableWebStream(), {
-        headers: {
-          "Content-Type": customEmoji.type,
-          "Content-Length": fileInfo.size.toString(),
-          "Cache-Control": "public, max-age=31536000, immutable",
-          "Last-Modified": (fileInfo.mtime ?? new Date()).toUTCString(),
-          "ETag": `"${fileInfo.mtime?.getTime().toString(36)}${
-            fileInfo.size.toString(36)
-          }"`,
-        },
-      });
-    }
-    return await app.fetch(request, { bot: this, contextData });
+  fetch(request: Request, contextData: TContextData): Promise<Response> {
+    return this.instance.fetch(request, contextData);
   }
 
   getEmoji(
@@ -1189,63 +1116,448 @@ export class BotImpl<TContextData> implements Bot<TContextData> {
     name: string,
     data: CustomEmoji,
   ): APEmoji {
-    let url: URL;
-    if ("url" in data) {
-      url = new URL(data.url);
-    } else {
-      // @ts-ignore: data.type satisfies keyof typeof mimeDb
-      const t = mimeDb[data.type];
-      url = new URL(
-        `/emojis/${name}${
-          t == null || t.extensions == null || t.extensions.length < 1
-            ? ""
-            : `.${t.extensions[0]}`
-        }`,
-        ctx.origin,
-      );
-    }
-    return new APEmoji({
-      id: ctx.getObjectUri(APEmoji, { name }),
-      name: `:${name}:`,
-      icon: new Image({
-        mediaType: data.type,
-        url,
-      }),
-    });
+    return this.instance.getEmoji(ctx, name, data);
   }
 
   addCustomEmoji<TEmojiName extends string>(
     name: TEmojiName,
     data: CustomEmoji,
   ): DeferredCustomEmoji<TContextData> {
-    if (!name.match(/^[a-z0-9-_]+$/i)) {
-      throw new TypeError(
-        `Invalid custom emoji name: ${name}. It must match /^[a-z0-9-_]+$/i.`,
-      );
-    } else if (name in this.customEmojis) {
-      throw new TypeError(`Duplicate custom emoji name: ${name}`);
-    } else if (!data.type.startsWith("image/")) {
-      throw new TypeError(`Unsupported media type: ${data.type}`);
-    }
-    this.customEmojis[name] = data;
-    return (session: Session<TContextData>) =>
-      this.getEmoji(
-        session.context,
-        name,
-        data,
-      );
+    return this.instance.addCustomEmoji(name, data);
   }
 
   addCustomEmojis<TEmojiName extends string>(
     emojis: Readonly<Record<TEmojiName, CustomEmoji>>,
   ): Readonly<Record<TEmojiName, DeferredCustomEmoji<TContextData>>> {
-    const emojiMap = {} as Record<
-      TEmojiName,
-      DeferredCustomEmoji<TContextData>
-    >;
-    for (const name in emojis) {
-      emojiMap[name] = this.addCustomEmoji(name, emojis[name]);
+    return this.instance.addCustomEmojis(emojis);
+  }
+}
+
+/**
+ * Wraps a {@link BotImpl} instance with a plain object implementing
+ * the {@link Bot} interface.  Since `deno serve` does not recognize a class
+ * instance having fetch(), we wrap a BotImpl instance with a plain object.
+ * See also https://github.com/denoland/deno/issues/24062
+ * @param bot The bot implementation to wrap.
+ * @returns The wrapped bot.
+ * @internal
+ */
+export function wrapBotImpl<TContextData>(
+  bot: BotImpl<TContextData>,
+): Bot<TContextData> {
+  const wrapper = {
+    impl: bot,
+    get federation() {
+      return bot.federation;
+    },
+    get identifier() {
+      return bot.identifier;
+    },
+    getSession(a, b?) {
+      // @ts-ignore: BotImpl.getSession() implements Bot.getSession()
+      return bot.getSession(a, b);
+    },
+    fetch(request, contextData) {
+      return bot.fetch(request, contextData);
+    },
+    addCustomEmojis<TEmojiName extends string>(
+      emojis: Readonly<Record<TEmojiName, CustomEmoji>>,
+    ): Readonly<Record<TEmojiName, DeferredCustomEmoji<TContextData>>> {
+      return bot.addCustomEmojis(emojis);
+    },
+    get onFollow() {
+      return bot.onFollow;
+    },
+    set onFollow(value) {
+      bot.onFollow = value;
+    },
+    get onUnfollow() {
+      return bot.onUnfollow;
+    },
+    set onUnfollow(value) {
+      bot.onUnfollow = value;
+    },
+    get onAcceptFollow() {
+      return bot.onAcceptFollow;
+    },
+    set onAcceptFollow(value) {
+      bot.onAcceptFollow = value;
+    },
+    get onRejectFollow() {
+      return bot.onRejectFollow;
+    },
+    set onRejectFollow(value) {
+      bot.onRejectFollow = value;
+    },
+    get onMention() {
+      return bot.onMention;
+    },
+    set onMention(value) {
+      bot.onMention = value;
+    },
+    get onReply() {
+      return bot.onReply;
+    },
+    set onReply(value) {
+      bot.onReply = value;
+    },
+    get onQuote() {
+      return bot.onQuote;
+    },
+    set onQuote(value) {
+      bot.onQuote = value;
+    },
+    get onMessage() {
+      return bot.onMessage;
+    },
+    set onMessage(value) {
+      bot.onMessage = value;
+    },
+    get onSharedMessage() {
+      return bot.onSharedMessage;
+    },
+    set onSharedMessage(value) {
+      bot.onSharedMessage = value;
+    },
+    get onLike() {
+      return bot.onLike;
+    },
+    set onLike(value) {
+      bot.onLike = value;
+    },
+    get onUnlike() {
+      return bot.onUnlike;
+    },
+    set onUnlike(value) {
+      bot.onUnlike = value;
+    },
+    get onReact() {
+      return bot.onReact;
+    },
+    set onReact(value) {
+      bot.onReact = value;
+    },
+    get onUnreact() {
+      return bot.onUnreact;
+    },
+    set onUnreact(value) {
+      bot.onUnreact = value;
+    },
+    get onVote() {
+      return bot.onVote;
+    },
+    set onVote(value) {
+      bot.onVote = value;
+    },
+  } satisfies Bot<TContextData> & { impl: BotImpl<TContextData> };
+  return wrapper;
+}
+
+/**
+ * A repository decorator that adopts legacy (pre-0.5) data for a bot actor
+ * before the first repository operation.  The migration is kicked off at
+ * construction time and every operation awaits its completion, so data
+ * stored by BotKit 0.4 or earlier is visible from the start.
+ * @internal
+ */
+export class MigrationGatedRepository implements Repository {
+  readonly #repository: Repository;
+  readonly #migration: Promise<void>;
+
+  constructor(repository: Repository, identifier: string) {
+    this.#repository = repository;
+    this.#migration = repository.migrate?.(identifier) ?? Promise.resolve();
+    // The rejection is re-thrown by the first awaiting operation; this
+    // no-op handler only prevents an unhandled rejection warning:
+    this.#migration.catch(() => {});
+  }
+
+  async setKeyPairs(
+    identifier: string,
+    keyPairs: CryptoKeyPair[],
+  ): Promise<void> {
+    await this.#migration;
+    return await this.#repository.setKeyPairs(identifier, keyPairs);
+  }
+
+  async getKeyPairs(identifier: string): Promise<CryptoKeyPair[] | undefined> {
+    await this.#migration;
+    return await this.#repository.getKeyPairs(identifier);
+  }
+
+  async addMessage(
+    identifier: string,
+    id: Uuid,
+    activity: Create | Announce,
+  ): Promise<void> {
+    await this.#migration;
+    return await this.#repository.addMessage(identifier, id, activity);
+  }
+
+  async updateMessage(
+    identifier: string,
+    id: Uuid,
+    updater: (
+      existing: Create | Announce,
+    ) => Create | Announce | undefined | Promise<Create | Announce | undefined>,
+  ): Promise<boolean> {
+    await this.#migration;
+    return await this.#repository.updateMessage(identifier, id, updater);
+  }
+
+  async removeMessage(
+    identifier: string,
+    id: Uuid,
+  ): Promise<Create | Announce | undefined> {
+    await this.#migration;
+    return await this.#repository.removeMessage(identifier, id);
+  }
+
+  async *getMessages(
+    identifier: string,
+    options?: RepositoryGetMessagesOptions,
+  ): AsyncIterable<Create | Announce> {
+    await this.#migration;
+    yield* this.#repository.getMessages(identifier, options);
+  }
+
+  async getMessage(
+    identifier: string,
+    id: Uuid,
+  ): Promise<Create | Announce | undefined> {
+    await this.#migration;
+    return await this.#repository.getMessage(identifier, id);
+  }
+
+  async countMessages(identifier: string): Promise<number> {
+    await this.#migration;
+    return await this.#repository.countMessages(identifier);
+  }
+
+  async addFollower(
+    identifier: string,
+    followId: URL,
+    follower: Actor,
+  ): Promise<void> {
+    await this.#migration;
+    return await this.#repository.addFollower(identifier, followId, follower);
+  }
+
+  async removeFollower(
+    identifier: string,
+    followId: URL,
+    followerId: URL,
+  ): Promise<Actor | undefined> {
+    await this.#migration;
+    return await this.#repository.removeFollower(
+      identifier,
+      followId,
+      followerId,
+    );
+  }
+
+  async hasFollower(identifier: string, followerId: URL): Promise<boolean> {
+    await this.#migration;
+    return await this.#repository.hasFollower(identifier, followerId);
+  }
+
+  async *getFollowers(
+    identifier: string,
+    options?: RepositoryGetFollowersOptions,
+  ): AsyncIterable<Actor> {
+    await this.#migration;
+    yield* this.#repository.getFollowers(identifier, options);
+  }
+
+  async countFollowers(identifier: string): Promise<number> {
+    await this.#migration;
+    return await this.#repository.countFollowers(identifier);
+  }
+
+  async addSentFollow(
+    identifier: string,
+    id: Uuid,
+    follow: Follow,
+  ): Promise<void> {
+    await this.#migration;
+    return await this.#repository.addSentFollow(identifier, id, follow);
+  }
+
+  async removeSentFollow(
+    identifier: string,
+    id: Uuid,
+  ): Promise<Follow | undefined> {
+    await this.#migration;
+    return await this.#repository.removeSentFollow(identifier, id);
+  }
+
+  async getSentFollow(
+    identifier: string,
+    id: Uuid,
+  ): Promise<Follow | undefined> {
+    await this.#migration;
+    return await this.#repository.getSentFollow(identifier, id);
+  }
+
+  async addFollowee(
+    identifier: string,
+    followeeId: URL,
+    follow: Follow,
+  ): Promise<void> {
+    await this.#migration;
+    return await this.#repository.addFollowee(identifier, followeeId, follow);
+  }
+
+  async removeFollowee(
+    identifier: string,
+    followeeId: URL,
+  ): Promise<Follow | undefined> {
+    await this.#migration;
+    return await this.#repository.removeFollowee(identifier, followeeId);
+  }
+
+  async getFollowee(
+    identifier: string,
+    followeeId: URL,
+  ): Promise<Follow | undefined> {
+    await this.#migration;
+    return await this.#repository.getFollowee(identifier, followeeId);
+  }
+
+  async *findFollowedBots(followeeId: URL): AsyncIterable<string> {
+    await this.#migration;
+    yield* this.#repository.findFollowedBots(followeeId);
+  }
+
+  async vote(
+    identifier: string,
+    messageId: Uuid,
+    voterId: URL,
+    option: string,
+  ): Promise<void> {
+    await this.#migration;
+    return await this.#repository.vote(identifier, messageId, voterId, option);
+  }
+
+  async countVoters(identifier: string, messageId: Uuid): Promise<number> {
+    await this.#migration;
+    return await this.#repository.countVoters(identifier, messageId);
+  }
+
+  async countVotes(
+    identifier: string,
+    messageId: Uuid,
+  ): Promise<Readonly<Record<string, number>>> {
+    await this.#migration;
+    return await this.#repository.countVotes(identifier, messageId);
+  }
+
+  forIdentifier(identifier: string): ActorScopedRepository {
+    return new ActorScopedRepository(this, identifier);
+  }
+
+  async migrate(identifier: string): Promise<void> {
+    await this.#migration;
+    await this.#repository.migrate?.(identifier);
+  }
+}
+
+/**
+ * The internal implementation of a {@link BotGroup}: a registry of event
+ * handlers shared by every bot its dispatcher resolves.
+ * @internal
+ */
+export class BotGroupImpl<TContextData> implements BotGroup<TContextData> {
+  readonly instance: InstanceImpl<TContextData>;
+  readonly dispatcher: BotDispatcher<TContextData>;
+  readonly mapUsername?: (
+    ctx: Context<TContextData>,
+    username: string,
+  ) => string | null | Promise<string | null>;
+
+  onFollow?: FollowEventHandler<TContextData>;
+  onUnfollow?: UnfollowEventHandler<TContextData>;
+  onAcceptFollow?: AcceptEventHandler<TContextData>;
+  onRejectFollow?: RejectEventHandler<TContextData>;
+  onMention?: MentionEventHandler<TContextData>;
+  onReply?: ReplyEventHandler<TContextData>;
+  onQuote?: QuoteEventHandler<TContextData>;
+  onMessage?: MessageEventHandler<TContextData>;
+  onSharedMessage?: SharedMessageEventHandler<TContextData>;
+  onLike?: LikeEventHandler<TContextData>;
+  onUnlike?: UnlikeEventHandler<TContextData>;
+  onReact?: ReactionEventHandler<TContextData>;
+  onUnreact?: UndoneReactionEventHandler<TContextData>;
+  onVote?: VoteEventHandler<TContextData>;
+
+  constructor(
+    instance: InstanceImpl<TContextData>,
+    dispatcher: BotDispatcher<TContextData>,
+    options: CreateBotGroupOptions<TContextData> = {},
+  ) {
+    this.instance = instance;
+    this.dispatcher = dispatcher;
+    this.mapUsername = options.mapUsername;
+  }
+
+  async getSession(
+    origin: string | URL,
+    identifier: string,
+    contextData: TContextData,
+  ): Promise<Session<TContextData>> {
+    const ctx = this.instance.federation.createContext(
+      new URL(origin),
+      contextData,
+    );
+    const bot = await this.instance.resolveBot(ctx, identifier);
+    if (bot == null || !(bot instanceof GroupBotImpl) || bot.group !== this) {
+      throw new TypeError(
+        `The group's dispatcher does not resolve the identifier: ${identifier}`,
+      );
+    }
+    return bot.getSession(ctx);
+  }
+}
+
+/**
+ * A transient per-bot view of a dynamically resolved bot.  It behaves like
+ * a regular {@link BotImpl}, except that its event handlers are read live
+ * from the owning {@link BotGroupImpl} at dispatch time, so handlers
+ * registered on the group after a bot was resolved still fire.  Views are
+ * not registered on the instance and live only as long as the resolution
+ * cache of the request that produced them.
+ * @internal
+ */
+export class GroupBotImpl<TContextData> extends BotImpl<TContextData> {
+  readonly group: BotGroupImpl<TContextData>;
+
+  constructor(
+    group: BotGroupImpl<TContextData>,
+    identifier: string,
+    profile: BotProfile<TContextData>,
+  ) {
+    super({
+      instance: group.instance,
+      transient: true,
+      identifier,
+      kv: group.instance.kv,
+      class: profile.class,
+      username: profile.username,
+      name: profile.name,
+      summary: profile.summary,
+      icon: profile.icon,
+      image: profile.image,
+      properties: profile.properties,
+      followerPolicy: profile.followerPolicy,
+    });
+    this.group = group;
+    for (const name of botEventHandlerNames) {
+      // Class fields would shadow prototype accessors, so the live views
+      // into the group's handlers are defined per instance:
+      globalThis.Object.defineProperty(this, name, {
+        get: () => group[name],
+        configurable: true,
+      });
     }
-    return emojiMap;
   }
 }
diff --git a/packages/botkit/src/bot.test.ts b/packages/botkit/src/bot.test.ts
index 724ba87..76a811a 100644
--- a/packages/botkit/src/bot.test.ts
+++ b/packages/botkit/src/bot.test.ts
@@ -18,7 +18,8 @@ import type { Actor } from "@fedify/vocab";
 import assert from "node:assert";
 import { test } from "node:test";
 import type { BotImpl } from "./bot-impl.ts";
-import { createBot } from "./bot.ts";
+import { MemoryRepository } from "./repository.ts";
+import { createBot, type ReadonlyBot } from "./bot.ts";
 import type { FollowRequest } from "./follow.ts";
 import type { Message, MessageClass, SharedMessage } from "./message.ts";
 import type { Like } from "./reaction.ts";
@@ -119,3 +120,63 @@ test("createBot()", async () => {
     subject: "acct:bot@example.com",
   });
 });
+
+test("Session.bot is a ReadonlyBot", () => {
+  const bot = createBot<void>({
+    kv: new MemoryKvStore(),
+    username: "readonlybot",
+  });
+  const session = bot.getSession("https://example.com");
+  const view: ReadonlyBot = session.bot;
+  assert.deepStrictEqual(view.identifier, "bot");
+  assert.deepStrictEqual(view.username, "readonlybot");
+  assert.deepStrictEqual(view.followerPolicy, "accept");
+
+  // Event handlers must not be reachable through the session's bot view:
+  // @ts-expect-error: ReadonlyBot does not expose event handlers.
+  session.bot.onMention = undefined;
+  // @ts-expect-error: ReadonlyBot does not expose the repository.
+  session.bot.repository;
+});
+
+test("createBot() adopts legacy repository data", async () => {
+  const kv = new MemoryKvStore();
+  // Simulates the unscoped key layout of BotKit 0.4 and earlier:
+  const messageId = "01941f29-7c00-7fe8-ab0a-7b593990a3c0";
+  await kv.set(["_botkit", "messages"], [messageId]);
+  await kv.set(["_botkit", "messages", messageId], {
+    "@context": "https://www.w3.org/ns/activitystreams",
+    type: "Create",
+    id: `https://example.com/ap/create/${messageId}`,
+    actor: "https://example.com/ap/actor/bot",
+    object: {
+      type: "Note",
+      id: `https://example.com/ap/note/${messageId}`,
+      content: "Hello, world!",
+    },
+  });
+  const bot = createBot<void>({ kv, username: "bot" });
+  const { impl } = bot as unknown as { impl: BotImpl<void> };
+  // The legacy message is adopted before the first repository operation:
+  assert.deepStrictEqual(await impl.repository.countMessages(), 1);
+});
+
+test("createBot() runs Repository.migrate() once", async () => {
+  class MigratingMemoryRepository extends MemoryRepository {
+    migrated: string[] = [];
+    migrate(identifier: string): Promise<void> {
+      this.migrated.push(identifier);
+      return Promise.resolve();
+    }
+  }
+  const repository = new MigratingMemoryRepository();
+  const bot = createBot<void>({
+    kv: new MemoryKvStore(),
+    repository,
+    username: "bot",
+  });
+  const { impl } = bot as unknown as { impl: BotImpl<void> };
+  await impl.repository.countMessages();
+  await impl.repository.countFollowers();
+  assert.deepStrictEqual(repository.migrated, ["bot"]);
+});
diff --git a/packages/botkit/src/bot.ts b/packages/botkit/src/bot.ts
index beaf79b..fae5054 100644
--- a/packages/botkit/src/bot.ts
+++ b/packages/botkit/src/bot.ts
@@ -21,7 +21,7 @@ import type {
 } from "@fedify/fedify/federation";
 import type { Software } from "@fedify/fedify/nodeinfo";
 import type { Application, Image, Service } from "@fedify/vocab";
-import { BotImpl } from "./bot-impl.ts";
+import { BotImpl, wrapBotImpl } from "./bot-impl.ts";
 import type { CustomEmoji, DeferredCustomEmoji } from "./emoji.ts";
 import type {
   AcceptEventHandler,
@@ -46,65 +46,12 @@ export { type Software } from "@fedify/fedify/nodeinfo";
 export { Application, Image, Service } from "@fedify/vocab";
 
 /**
- * A bot that can interact with the ActivityPub network.
+ * The event handlers a bot can register.  Assigning a handler to one of
+ * these properties makes the bot react to the corresponding ActivityPub
+ * activity.
+ * @since 0.5.0
  */
-export interface Bot<TContextData> {
-  /**
-   * An internal Fedify federation instance.  Normally you don't need to access
-   * this directly.
-   */
-  readonly federation: Federation<TContextData>;
-
-  /**
-   * The internal identifier for the bot actor.  It is used for the actor URI.
-   */
-  readonly identifier: string;
-
-  /**
-   * Gets a new session to control the bot for a specific origin and context
-   * data.
-   * @param origin The origin of the session.  Even if a URL with some path or
-   *               query is passed, only the origin part will be used.
-   * @param contextData The context data to pass to the federation.
-   * @returns The session for the origin and context data.
-   */
-  getSession(
-    origin: string | URL,
-    contextData: TContextData,
-  ): Session<TContextData>;
-
-  /**
-   * Gets a new session to control bot for a specific Fedify context.
-   * @param context The Fedify context of the session.
-   * @returns The session for the Fedify context.
-   */
-  getSession(context: Context<TContextData>): Session<TContextData>;
-
-  /**
-   * The fetch API for handling HTTP requests.  You can pass this to an HTTP
-   * server (e.g., `Deno.serve()`, `Bun.serve()`) to handle incoming requests.
-   * @param request The request to handle.
-   * @param contextData The context data to pass to the federation.
-   * @returns The response to the request.
-   */
-  fetch(request: Request, contextData: TContextData): Promise<Response>;
-
-  /**
-   * Defines custom emojis for the bot.  The custom emojis are used for
-   * rendering the bot's profile and posts.  The custom emojis are defined
-   * by their names, and the names are used as the keys of the emojis.
-   * @param emojis The custom emojis to define.  The keys are the names of
-   *               the emojis, and the values are the custom emoji definitions.
-   * @returns The defined emojis.  The keys are the names of the emojis, and
-   *          the values are the emoji objects, which are used for passing
-   *          to the {@link customEmoji} function.
-   * @throws {TypeError} If any emoji name is invalid or duplicate.
-   * @since 0.2.0
-   */
-  addCustomEmojis<TEmojiName extends string>(
-    emojis: Readonly<Record<TEmojiName, CustomEmoji>>,
-  ): Readonly<Record<TEmojiName, DeferredCustomEmoji<TContextData>>>;
-
+export interface BotEventHandlers<TContextData> {
   /**
    * An event handler for a follow request to the bot.
    */
@@ -191,6 +138,111 @@ export interface Bot<TContextData> {
   onVote?: VoteEventHandler<TContextData>;
 }
 
+/**
+ * A read-only view of a bot actor's identity and profile.  It is exposed
+ * through {@link Session.bot} so that event handlers can tell which bot they
+ * are running as without being able to mutate the bot (e.g. reassign its
+ * event handlers).
+ * @since 0.5.0
+ */
+export interface ReadonlyBot {
+  /**
+   * The internal identifier for the bot actor.  It is used for the actor URI.
+   */
+  readonly identifier: string;
+
+  /**
+   * The username of the bot.  It is a part of the fediverse handle.
+   */
+  readonly username: string;
+
+  /**
+   * The display name of the bot.
+   */
+  readonly name?: string;
+
+  /**
+   * The type of the bot actor.  It is either `Service` or `Application`.
+   */
+  readonly class: typeof Service | typeof Application;
+
+  /**
+   * The avatar URL of the bot.
+   */
+  readonly icon?: URL | Image;
+
+  /**
+   * The header image URL of the bot.
+   */
+  readonly image?: URL | Image;
+
+  /**
+   * How the bot handles incoming follow requests.
+   */
+  readonly followerPolicy: "accept" | "reject" | "manual";
+}
+
+/**
+ * A bot that can interact with the ActivityPub network.
+ */
+export interface Bot<TContextData> extends BotEventHandlers<TContextData> {
+  /**
+   * An internal Fedify federation instance.  Normally you don't need to access
+   * this directly.
+   */
+  readonly federation: Federation<TContextData>;
+
+  /**
+   * The internal identifier for the bot actor.  It is used for the actor URI.
+   */
+  readonly identifier: string;
+
+  /**
+   * Gets a new session to control the bot for a specific origin and context
+   * data.
+   * @param origin The origin of the session.  Even if a URL with some path or
+   *               query is passed, only the origin part will be used.
+   * @param contextData The context data to pass to the federation.
+   * @returns The session for the origin and context data.
+   */
+  getSession(
+    origin: string | URL,
+    contextData: TContextData,
+  ): Session<TContextData>;
+
+  /**
+   * Gets a new session to control bot for a specific Fedify context.
+   * @param context The Fedify context of the session.
+   * @returns The session for the Fedify context.
+   */
+  getSession(context: Context<TContextData>): Session<TContextData>;
+
+  /**
+   * The fetch API for handling HTTP requests.  You can pass this to an HTTP
+   * server (e.g., `Deno.serve()`, `Bun.serve()`) to handle incoming requests.
+   * @param request The request to handle.
+   * @param contextData The context data to pass to the federation.
+   * @returns The response to the request.
+   */
+  fetch(request: Request, contextData: TContextData): Promise<Response>;
+
+  /**
+   * Defines custom emojis for the bot.  The custom emojis are used for
+   * rendering the bot's profile and posts.  The custom emojis are defined
+   * by their names, and the names are used as the keys of the emojis.
+   * @param emojis The custom emojis to define.  The keys are the names of
+   *               the emojis, and the values are the custom emoji definitions.
+   * @returns The defined emojis.  The keys are the names of the emojis, and
+   *          the values are the emoji objects, which are used for passing
+   *          to the {@link customEmoji} function.
+   * @throws {TypeError} If any emoji name is invalid or duplicate.
+   * @since 0.2.0
+   */
+  addCustomEmojis<TEmojiName extends string>(
+    emojis: Readonly<Record<TEmojiName, CustomEmoji>>,
+  ): Readonly<Record<TEmojiName, DeferredCustomEmoji<TContextData>>>;
+}
+
 /**
  * A specialized {@link Bot} tpe that doesn't require context data.
  */
@@ -385,114 +437,6 @@ export function createBot<TContextData = void>(
   options: CreateBotOptions<TContextData>,
 ): TContextData extends void ? BotWithVoidContextData : Bot<TContextData> {
   const bot = new BotImpl<TContextData>(options);
-  // Since `deno serve` does not recognize a class instance having fetch(),
-  // we wrap a BotImpl instance with a plain object.
-  // See also https://github.com/denoland/deno/issues/24062
-  const wrapper = {
-    impl: bot,
-    get federation() {
-      return bot.federation;
-    },
-    get identifier() {
-      return bot.identifier;
-    },
-    getSession(a, b?) {
-      // @ts-ignore: BotImpl.getSession() implements Bot.getSession()
-      return bot.getSession(a, b);
-    },
-    fetch(request, contextData) {
-      return bot.fetch(request, contextData);
-    },
-    addCustomEmojis<TEmojiName extends string>(
-      emojis: Readonly<Record<TEmojiName, CustomEmoji>>,
-    ): Readonly<Record<TEmojiName, DeferredCustomEmoji<TContextData>>> {
-      return bot.addCustomEmojis(emojis);
-    },
-    get onFollow() {
-      return bot.onFollow;
-    },
-    set onFollow(value) {
-      bot.onFollow = value;
-    },
-    get onUnfollow() {
-      return bot.onUnfollow;
-    },
-    set onUnfollow(value) {
-      bot.onUnfollow = value;
-    },
-    get onAcceptFollow() {
-      return bot.onAcceptFollow;
-    },
-    set onAcceptFollow(value) {
-      bot.onAcceptFollow = value;
-    },
-    get onRejectFollow() {
-      return bot.onRejectFollow;
-    },
-    set onRejectFollow(value) {
-      bot.onRejectFollow = value;
-    },
-    get onMention() {
-      return bot.onMention;
-    },
-    set onMention(value) {
-      bot.onMention = value;
-    },
-    get onReply() {
-      return bot.onReply;
-    },
-    set onReply(value) {
-      bot.onReply = value;
-    },
-    get onQuote() {
-      return bot.onQuote;
-    },
-    set onQuote(value) {
-      bot.onQuote = value;
-    },
-    get onMessage() {
-      return bot.onMessage;
-    },
-    set onMessage(value) {
-      bot.onMessage = value;
-    },
-    get onSharedMessage() {
-      return bot.onSharedMessage;
-    },
-    set onSharedMessage(value) {
-      bot.onSharedMessage = value;
-    },
-    get onLike() {
-      return bot.onLike;
-    },
-    set onLike(value) {
-      bot.onLike = value;
-    },
-    get onUnlike() {
-      return bot.onUnlike;
-    },
-    set onUnlike(value) {
-      bot.onUnlike = value;
-    },
-    get onReact() {
-      return bot.onReact;
-    },
-    set onReact(value) {
-      bot.onReact = value;
-    },
-    get onUnreact() {
-      return bot.onUnreact;
-    },
-    set onUnreact(value) {
-      bot.onUnreact = value;
-    },
-    get onVote() {
-      return bot.onVote;
-    },
-    set onVote(value) {
-      bot.onVote = value;
-    },
-  } satisfies Bot<TContextData> & { impl: BotImpl<TContextData> };
   // @ts-ignore: the wrapper implements BotWithVoidContextData
-  return wrapper;
+  return wrapBotImpl(bot);
 }
diff --git a/packages/botkit/src/components/FollowButton.tsx b/packages/botkit/src/components/FollowButton.tsx
index a49ccc7..9d4bc13 100644
--- a/packages/botkit/src/components/FollowButton.tsx
+++ b/packages/botkit/src/components/FollowButton.tsx
@@ -3,9 +3,10 @@ import type { BotImpl } from "../bot-impl.ts";
 
 export interface FollowButtonProps {
   readonly bot: BotImpl<unknown>;
+  readonly action?: string;
 }
 
-export function FollowButton({ bot }: FollowButtonProps) {
+export function FollowButton({ bot, action }: FollowButtonProps) {
   return (
     <>
       <button
@@ -29,7 +30,7 @@ export function FollowButton({ bot }: FollowButtonProps) {
           </header>
           <main>
             <p>Enter your fediverse handle to follow this account:</p>
-            <form action="/follow" method="post">
+            <form action={action ?? "/follow"} method="post">
               <input
                 type="text"
                 id="fediverse-handle"
diff --git a/packages/botkit/src/components/Layout.tsx b/packages/botkit/src/components/Layout.tsx
index 8da55b8..e20b9b9 100644
--- a/packages/botkit/src/components/Layout.tsx
+++ b/packages/botkit/src/components/Layout.tsx
@@ -62,7 +62,7 @@ export function Layout(
           rel="stylesheet"
           href={`https://cdn.jsdelivr.net/npm/@picocss/pico@2/css/${cssFilename}`}
         />
-        <style>{bot.pages.css}</style>
+        <style dangerouslySetInnerHTML={{ __html: bot.pages.css }} />
       </head>
       <body>
         {children}
diff --git a/packages/botkit/src/follow-impl.test.ts b/packages/botkit/src/follow-impl.test.ts
index 6c72a1e..867fed4 100644
--- a/packages/botkit/src/follow-impl.test.ts
+++ b/packages/botkit/src/follow-impl.test.ts
@@ -69,9 +69,14 @@ test("FollowRequestImpl.accept()", async () => {
   await followRequest.accept();
   assert.deepStrictEqual(followRequest.state, "accepted");
   assert.ok(
-    await repository.hasFollower(new URL("https://example.com/ap/actor/john")),
+    await repository.hasFollower(
+      "bot",
+      new URL("https://example.com/ap/actor/john"),
+    ),
+  );
+  const [storedFollower] = await Array.fromAsync(
+    repository.getFollowers("bot"),
   );
-  const [storedFollower] = await Array.fromAsync(repository.getFollowers());
   assert.ok(storedFollower != null);
   assert.deepStrictEqual(storedFollower.id, follower.id);
   assert.deepStrictEqual(
@@ -121,7 +126,10 @@ test("FollowRequestImpl.reject()", async () => {
   await followRequest.reject();
   assert.deepStrictEqual(followRequest.state, "rejected");
   assert.deepStrictEqual(
-    await repository.hasFollower(new URL("https://example.com/ap/actor/john")),
+    await repository.hasFollower(
+      "bot",
+      new URL("https://example.com/ap/actor/john"),
+    ),
     false,
   );
   assert.deepStrictEqual(ctx.sentActivities.length, 1);
diff --git a/packages/botkit/src/instance-impl.test.ts b/packages/botkit/src/instance-impl.test.ts
new file mode 100644
index 0000000..7d250ac
--- /dev/null
+++ b/packages/botkit/src/instance-impl.test.ts
@@ -0,0 +1,167 @@
+// BotKit by Fedify: A framework for creating ActivityPub bots
+// Copyright (C) 2025–2026 Hong Minhee <https://hongminhee.org/>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+import { MemoryKvStore } from "@fedify/fedify/federation";
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { createInstance } from "./instance.ts";
+
+describe("createInstance()", () => {
+  test("serves a static bot's actor", async () => {
+    const instance = createInstance<void>({ kv: new MemoryKvStore() });
+    const bot = instance.createBot("bot", {
+      username: "mybot",
+      name: "My Bot",
+    });
+    assert.deepStrictEqual(bot.identifier, "bot");
+
+    const response = await instance.fetch(
+      new Request("https://example.com/ap/actor/bot", {
+        headers: { Accept: "application/activity+json" },
+      }),
+    );
+    assert.deepStrictEqual(response.status, 200);
+    const actor = await response.json();
+    assert.deepStrictEqual(actor.preferredUsername, "mybot");
+    assert.deepStrictEqual(actor.name, "My Bot");
+  });
+
+  test("serves WebFinger for a static bot", async () => {
+    const instance = createInstance<void>({ kv: new MemoryKvStore() });
+    instance.createBot("bot", { username: "mybot" });
+    const response = await instance.fetch(
+      new Request(
+        "https://example.com/.well-known/webfinger?resource=acct:mybot@example.com",
+      ),
+    );
+    assert.deepStrictEqual(response.status, 200);
+    const jrd = await response.json();
+    assert.deepStrictEqual(jrd.subject, "acct:mybot@example.com");
+  });
+
+  test("returns 404 for unregistered identifiers", async () => {
+    const instance = createInstance<void>({ kv: new MemoryKvStore() });
+    instance.createBot("bot", { username: "mybot" });
+    const response = await instance.fetch(
+      new Request("https://example.com/ap/actor/nonexistent", {
+        headers: { Accept: "application/activity+json" },
+      }),
+    );
+    assert.deepStrictEqual(response.status, 404);
+  });
+
+  test("rejects duplicate identifiers and usernames", () => {
+    const instance = createInstance<void>({ kv: new MemoryKvStore() });
+    instance.createBot("bot", { username: "mybot" });
+    assert.throws(
+      () => instance.createBot("bot", { username: "other" }),
+      TypeError,
+    );
+    assert.throws(
+      () => instance.createBot("other", { username: "mybot" }),
+      TypeError,
+    );
+  });
+
+  test("rejects usernames that differ only in case", () => {
+    const instance = createInstance<void>({ kv: new MemoryKvStore() });
+    instance.createBot("bot", { username: "mybot" });
+    // Fediverse usernames are matched case-insensitively (WebFinger acct:
+    // lookups and mentions vary in casing), so two bots whose usernames
+    // differ only in case would be indistinguishable:
+    assert.throws(
+      () => instance.createBot("other", { username: "MyBot" }),
+      TypeError,
+    );
+  });
+
+  test("serves WebFinger regardless of the username casing", async () => {
+    const instance = createInstance<void>({ kv: new MemoryKvStore() });
+    instance.createBot("bot", { username: "mybot" });
+    const response = await instance.fetch(
+      new Request(
+        "https://example.com/.well-known/webfinger?resource=acct:MyBot@example.com",
+      ),
+    );
+    assert.deepStrictEqual(response.status, 200);
+  });
+
+  test("registers event handlers through the returned bot", () => {
+    const instance = createInstance<void>({ kv: new MemoryKvStore() });
+    const bot = instance.createBot("bot", { username: "mybot" });
+    const handler = () => {};
+    bot.onMention = handler;
+    assert.deepStrictEqual(bot.onMention, handler);
+  });
+
+  test("creates sessions for a static bot", () => {
+    const instance = createInstance<void>({ kv: new MemoryKvStore() });
+    const bot = instance.createBot("bot", { username: "mybot" });
+    const session = bot.getSession("https://example.com");
+    assert.deepStrictEqual(
+      session.actorId.href,
+      "https://example.com/ap/actor/bot",
+    );
+    assert.deepStrictEqual(session.actorHandle, "@mybot@example.com");
+    assert.deepStrictEqual(session.bot.identifier, "bot");
+    assert.deepStrictEqual(session.bot.username, "mybot");
+  });
+
+  test("does not redirect legacy URIs without legacyObjectUris", async () => {
+    const instance = createInstance<void>({ kv: new MemoryKvStore() });
+    instance.createBot("bot", { username: "mybot" });
+    const response = await instance.fetch(
+      new Request("https://example.com/ap/note/123"),
+    );
+    assert.notDeepStrictEqual(response.status, 301);
+  });
+
+  test("redirects legacy URIs with legacyObjectUris", async () => {
+    const instance = createInstance<void>({
+      kv: new MemoryKvStore(),
+      legacyObjectUris: { identifier: "bot" },
+    });
+    instance.createBot("bot", { username: "mybot" });
+    const response = await instance.fetch(
+      new Request("https://example.com/ap/note/123"),
+    );
+    assert.deepStrictEqual(response.status, 301);
+    assert.deepStrictEqual(
+      response.headers.get("Location"),
+      "https://example.com/ap/actor/bot/note/123",
+    );
+  });
+
+  test("defines custom emojis at the instance level", () => {
+    const instance = createInstance<void>({ kv: new MemoryKvStore() });
+    const emojis = instance.addCustomEmojis({
+      wave: {
+        type: "image/png",
+        url: "https://example.com/emojis/wave.png",
+      },
+    });
+    assert.ok("wave" in emojis);
+    assert.throws(
+      () =>
+        instance.addCustomEmojis({
+          wave: {
+            type: "image/png",
+            url: "https://example.com/emojis/wave2.png",
+          },
+        }),
+      TypeError,
+    );
+  });
+});
diff --git a/packages/botkit/src/instance-impl.ts b/packages/botkit/src/instance-impl.ts
new file mode 100644
index 0000000..eef6ae0
--- /dev/null
+++ b/packages/botkit/src/instance-impl.ts
@@ -0,0 +1,1088 @@
+// BotKit by Fedify: A framework for creating ActivityPub bots
+// Copyright (C) 2025–2026 Hong Minhee <https://hongminhee.org/>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+import {
+  type Context,
+  createFederation,
+  type Federation,
+  generateCryptoKeyPair,
+  type InboxContext,
+  type KvStore,
+  type MessageQueue,
+  type NodeInfo,
+  type Software,
+} from "@fedify/fedify";
+import {
+  Accept,
+  type Activity,
+  type Actor,
+  Announce,
+  Application,
+  Article,
+  ChatMessage,
+  Create,
+  Delete,
+  Emoji as APEmoji,
+  Endpoints,
+  Follow,
+  Image,
+  Like as RawLike,
+  Link,
+  Mention,
+  Note,
+  Question,
+  Reject,
+  Undo,
+} from "@fedify/vocab";
+import { getLogger } from "@logtape/logtape";
+import mimeDb from "mime-db";
+import fs from "node:fs/promises";
+import { getXForwardedRequest } from "x-forwarded-fetch";
+import metadata from "../deno.json" with { type: "json" };
+import { BotImpl } from "./bot-impl.ts";
+import type { Bot, PagesOptions } from "./bot.ts";
+import { BotGroupImpl, GroupBotImpl, wrapBotImpl } from "./bot-impl.ts";
+import type { CustomEmoji, DeferredCustomEmoji } from "./emoji.ts";
+import type {
+  BotDispatcher,
+  BotGroup,
+  BotProfile,
+  CreateBotGroupOptions,
+  CreateInstanceOptions,
+  Instance,
+} from "./instance.ts";
+import { isMessageObject, isQuoteLink } from "./message-impl.ts";
+import { app, multiApp } from "./pages.tsx";
+import { KvRepository, type Repository } from "./repository.ts";
+import type { Session } from "./session.ts";
+import { parseLocalUri, rewriteLegacyObjectPath } from "./uri.ts";
+
+/**
+ * The default identifier of the instance actor: an internal `Application`
+ * actor that an {@link Instance} uses for signing shared-inbox related
+ * requests on behalf of the whole instance.  It can be overridden through
+ * the {@link CreateInstanceOptions.instanceActorIdentifier} option; either
+ * way, bots cannot take the effective identifier.
+ * @since 0.5.0
+ */
+export const DEFAULT_INSTANCE_ACTOR_IDENTIFIER = "__botkit_instance__";
+
+/**
+ * Options for creating an {@link InstanceImpl}.
+ * @internal
+ */
+export interface InstanceImplOptions extends CreateInstanceOptions {
+  collectionWindow?: number;
+
+  /**
+   * Whether the instance was created through the single-bot
+   * `createBot()` compatibility path.  A compatible instance keeps
+   * the pre-0.5 behavior: the sole bot's key signs shared-inbox
+   * requests and no instance actor is exposed.
+   */
+  compatMode?: boolean;
+}
+
+/**
+ * The internal implementation of an {@link Instance}.  It owns the single
+ * Fedify {@link Federation} shared by every bot hosted on the instance, and
+ * routes federation callbacks to the right bot by its identifier.
+ * @internal
+ */
+export class InstanceImpl<TContextData>
+  implements Omit<Instance<TContextData>, "createBot"> {
+  readonly kv: KvStore;
+  readonly queue?: MessageQueue;
+
+  /**
+   * The root repository shared by every bot hosted on the instance.
+   */
+  readonly repository: Repository;
+  readonly software?: Software;
+  readonly behindProxy: boolean;
+  readonly pages: Required<PagesOptions>;
+  readonly collectionWindow: number;
+  readonly federation: Federation<TContextData>;
+  readonly customEmojis: Record<string, CustomEmoji> = {};
+
+  /**
+   * The identifier of the bot actor that owns local objects whose URIs are
+   * in the legacy (pre-0.5) format, which did not carry the identifier.
+   */
+  readonly legacyObjectUrisIdentifier?: string;
+
+  /**
+   * Whether the instance was created through the single-bot
+   * `createBot()` compatibility path.
+   */
+  readonly compatMode: boolean;
+
+  /**
+   * The reserved identifier of the instance actor.
+   */
+  readonly instanceActorIdentifier: string;
+
+  readonly #bots: Map<string, BotImpl<TContextData>> = new Map();
+  readonly #groups: BotGroupImpl<TContextData>[] = [];
+
+  /**
+   * Memoizes dynamic bot resolution per Fedify context, which is stable
+   * for the duration of one HTTP dispatch or one queue-delivered inbox
+   * activity, so a dispatcher is invoked at most once per identifier per
+   * request.  Entries die with their context.
+   */
+  readonly #resolutionCache: WeakMap<
+    Context<TContextData>,
+    Map<string, BotImpl<TContextData> | null>
+  > = new WeakMap();
+
+  constructor(options: InstanceImplOptions) {
+    this.kv = options.kv;
+    this.queue = options.queue;
+    this.repository = options.repository ?? new KvRepository(options.kv);
+    this.software = options.software;
+    this.behindProxy = options.behindProxy ?? false;
+    this.pages = {
+      color: "green",
+      css: "",
+      ...(options.pages ?? {}),
+    };
+    this.collectionWindow = options.collectionWindow ?? 50;
+    this.legacyObjectUrisIdentifier = options.legacyObjectUris?.identifier;
+    this.compatMode = options.compatMode ?? false;
+    this.instanceActorIdentifier = options.instanceActorIdentifier ??
+      DEFAULT_INSTANCE_ACTOR_IDENTIFIER;
+    if (this.instanceActorIdentifier === "") {
+      throw new TypeError("The instance actor identifier cannot be empty.");
+    }
+    this.federation = createFederation<TContextData>({
+      kv: options.kv,
+      queue: options.queue,
+      userAgent: {
+        software: `BotKit/${metadata.version}`,
+      },
+    });
+    this.#initialize();
+  }
+
+  #initialize(): void {
+    this.federation
+      .setActorDispatcher(
+        "/ap/actor/{identifier}",
+        async (ctx, identifier) => {
+          if (
+            !this.compatMode && identifier === this.instanceActorIdentifier
+          ) {
+            return await this.#dispatchInstanceActor(ctx);
+          }
+          const bot = await this.resolveBot(ctx, identifier);
+          return await bot?.dispatchActor(ctx, identifier) ?? null;
+        },
+      )
+      .mapHandle((ctx, username) => this.mapHandle(ctx, username))
+      .setKeyPairsDispatcher(async (ctx, identifier) => {
+        if (
+          !this.compatMode && identifier === this.instanceActorIdentifier
+        ) {
+          return await this.#dispatchInstanceActorKeyPairs();
+        }
+        const bot = await this.resolveBot(ctx, identifier);
+        return await bot?.dispatchActorKeyPairs(ctx, identifier) ?? [];
+      });
+    this.federation
+      .setFollowersDispatcher(
+        "/ap/actor/{identifier}/followers",
+        async (ctx, identifier, cursor) => {
+          const bot = await this.resolveBot(ctx, identifier);
+          return await bot?.dispatchFollowers(ctx, identifier, cursor) ??
+            null;
+        },
+      )
+      .setFirstCursor(async (ctx, identifier) => {
+        const bot = await this.resolveBot(ctx, identifier);
+        return bot?.getFollowersFirstCursor(ctx, identifier) ?? null;
+      })
+      .setCounter(async (ctx, identifier) => {
+        const bot = await this.resolveBot(ctx, identifier);
+        return await bot?.countFollowers(ctx, identifier) ?? null;
+      });
+    this.federation
+      .setOutboxDispatcher(
+        "/ap/actor/{identifier}/outbox",
+        async (ctx, identifier, cursor) => {
+          const bot = await this.resolveBot(ctx, identifier);
+          return await bot?.dispatchOutbox(ctx, identifier, cursor) ?? null;
+        },
+      )
+      .setFirstCursor(async (ctx, identifier) => {
+        const bot = await this.resolveBot(ctx, identifier);
+        return bot?.getOutboxFirstCursor(ctx, identifier) ?? null;
+      })
+      .setCounter(async (ctx, identifier) => {
+        const bot = await this.resolveBot(ctx, identifier);
+        return await bot?.countOutbox(ctx, identifier) ?? null;
+      });
+    this.federation
+      .setObjectDispatcher(
+        Follow,
+        "/ap/actor/{identifier}/follow/{id}",
+        async (ctx, values) => {
+          const bot = await this.resolveBot(ctx, values.identifier);
+          return await bot?.dispatchFollow(ctx, values) ?? null;
+        },
+      )
+      .authorize(async (ctx, values) => {
+        const bot = await this.resolveBot(ctx, values.identifier);
+        return await bot?.authorizeFollow(ctx, values) ?? false;
+      });
+    this.federation.setObjectDispatcher(
+      Create,
+      "/ap/actor/{identifier}/create/{id}",
+      async (ctx, values) => {
+        const bot = await this.resolveBot(ctx, values.identifier);
+        return await bot?.dispatchCreate(ctx, values) ?? null;
+      },
+    );
+    this.federation.setObjectDispatcher(
+      Article,
+      "/ap/actor/{identifier}/article/{id}",
+      async (ctx, values) => {
+        const bot = await this.resolveBot(ctx, values.identifier);
+        return await bot?.dispatchMessage(Article, ctx, values.id) ?? null;
+      },
+    );
+    this.federation.setObjectDispatcher(
+      ChatMessage,
+      "/ap/actor/{identifier}/chat-message/{id}",
+      async (ctx, values) => {
+        const bot = await this.resolveBot(ctx, values.identifier);
+        return await bot?.dispatchMessage(ChatMessage, ctx, values.id) ??
+          null;
+      },
+    );
+    this.federation.setObjectDispatcher(
+      Note,
+      "/ap/actor/{identifier}/note/{id}",
+      async (ctx, values) => {
+        const bot = await this.resolveBot(ctx, values.identifier);
+        return await bot?.dispatchMessage(Note, ctx, values.id) ?? null;
+      },
+    );
+    this.federation.setObjectDispatcher(
+      Question,
+      "/ap/actor/{identifier}/question/{id}",
+      async (ctx, values) => {
+        const bot = await this.resolveBot(ctx, values.identifier);
+        return await bot?.dispatchMessage(Question, ctx, values.id) ?? null;
+      },
+    );
+    this.federation.setObjectDispatcher(
+      Announce,
+      "/ap/actor/{identifier}/announce/{id}",
+      async (ctx, values) => {
+        const bot = await this.resolveBot(ctx, values.identifier);
+        return await bot?.dispatchAnnounce(ctx, values) ?? null;
+      },
+    );
+    this.federation.setObjectDispatcher(
+      APEmoji,
+      "/ap/emoji/{name}",
+      (ctx, values) => this.dispatchEmoji(ctx, values),
+    );
+    this.federation
+      .setInboxListeners("/ap/actor/{identifier}/inbox", "/ap/inbox")
+      .onUnverifiedActivity((ctx, activity, reason) =>
+        this.onUnverifiedActivity(ctx, activity, reason)
+      )
+      .on(Follow, (ctx, follow) => this.onFollowed(ctx, follow))
+      .on(Undo, (ctx, undo) => this.onUndone(ctx, undo))
+      .on(Accept, (ctx, accept) => this.onFollowAccepted(ctx, accept))
+      .on(Reject, (ctx, reject) => this.onFollowRejected(ctx, reject))
+      .on(Create, (ctx, create) => this.onCreated(ctx, create))
+      .on(Announce, (ctx, announce) => this.onAnnounced(ctx, announce))
+      .on(RawLike, (ctx, like) => this.onLiked(ctx, like))
+      .setSharedKeyDispatcher((ctx) => this.dispatchSharedKey(ctx));
+    if (this.software != null) {
+      this.federation.setNodeInfoDispatcher(
+        "/nodeinfo/2.1",
+        (ctx) => this.dispatchNodeInfo(ctx),
+      );
+    }
+  }
+
+  /**
+   * Registers a bot on the instance.  Invoked by the {@link BotImpl}
+   * constructor.
+   * @param bot The bot to register.
+   * @throws {TypeError} If a bot with the same identifier or username
+   *                     already exists on the instance.
+   */
+  addBot(bot: BotImpl<TContextData>): void {
+    if (
+      !this.compatMode && bot.identifier === this.instanceActorIdentifier
+    ) {
+      throw new TypeError(
+        `The identifier is reserved for the instance actor: ${bot.identifier}`,
+      );
+    }
+    if (this.#bots.has(bot.identifier)) {
+      throw new TypeError(
+        `A bot with the identifier already exists: ${bot.identifier}`,
+      );
+    }
+    // Fediverse usernames are looked up case-insensitively (WebFinger
+    // acct: resources and mentions vary in casing), so two usernames
+    // differing only in case would be indistinguishable:
+    const username = bot.username.toLowerCase();
+    for (const existing of this.#bots.values()) {
+      if (existing.username.toLowerCase() === username) {
+        throw new TypeError(
+          `A bot with the username already exists: ${bot.username}`,
+        );
+      }
+    }
+    this.#bots.set(bot.identifier, bot);
+  }
+
+  /**
+   * Resolves a bot hosted on the instance by its identifier.
+   * @param identifier The identifier of the bot to resolve.
+   * @returns The resolved bot, or `undefined` if no bot has the identifier.
+   */
+  getBot(identifier: string): BotImpl<TContextData> | undefined {
+    return this.#bots.get(identifier);
+  }
+
+  /**
+   * Resolves a bot by its identifier: bots registered statically win, then
+   * the dynamic bot groups are probed in their registration order.
+   * Dynamic resolutions are memoized per context.
+   * @param ctx The Fedify context of the resolution.
+   * @param identifier The identifier of the bot to resolve.
+   * @returns The resolved bot, or `null` if no bot has the identifier.
+   */
+  async resolveBot(
+    ctx: Context<TContextData>,
+    identifier: string,
+  ): Promise<BotImpl<TContextData> | null> {
+    // The instance actor's identifier is reserved; no bot, static or
+    // dynamic, resolves under it.  (addBot() already rejects static bots
+    // with the reserved identifier; this keeps the invariant local.)
+    if (!this.compatMode && identifier === this.instanceActorIdentifier) {
+      return null;
+    }
+    const staticBot = this.#bots.get(identifier);
+    if (staticBot != null) return staticBot;
+    if (this.#groups.length < 1) return null;
+    let cache = this.#resolutionCache.get(ctx);
+    if (cache == null) {
+      cache = new Map();
+      this.#resolutionCache.set(ctx, cache);
+    }
+    const cached = cache.get(identifier);
+    if (cached !== undefined) return cached;
+    let resolved: BotImpl<TContextData> | null = null;
+    for (const group of this.#groups) {
+      const profile = await group.dispatcher(ctx, identifier);
+      if (profile != null) {
+        resolved = new GroupBotImpl(group, identifier, profile);
+        break;
+      }
+    }
+    cache.set(identifier, resolved);
+    return resolved;
+  }
+
+  /**
+   * Every bot hosted on the instance.
+   */
+  get bots(): Iterable<BotImpl<TContextData>> {
+    return this.#bots.values();
+  }
+
+  /**
+   * The number of bots hosted on the instance.
+   */
+  get botCount(): number {
+    return this.#bots.size;
+  }
+
+  #firstBot(): BotImpl<TContextData> | undefined {
+    return this.#bots.values().next().value;
+  }
+
+  createBot(
+    identifier: string,
+    profile: BotProfile<TContextData>,
+  ): Bot<TContextData>;
+  createBot(
+    dispatcher: BotDispatcher<TContextData>,
+    options?: CreateBotGroupOptions<TContextData>,
+  ): BotGroup<TContextData>;
+  createBot(
+    identifierOrDispatcher: string | BotDispatcher<TContextData>,
+    profileOrOptions?:
+      | BotProfile<TContextData>
+      | CreateBotGroupOptions<TContextData>,
+  ): Bot<TContextData> | BotGroup<TContextData> {
+    if (typeof identifierOrDispatcher !== "string") {
+      const group = new BotGroupImpl(
+        this,
+        identifierOrDispatcher,
+        profileOrOptions as CreateBotGroupOptions<TContextData> | undefined,
+      );
+      this.#groups.push(group);
+      return group;
+    }
+    const profile = profileOrOptions as BotProfile<TContextData> | undefined;
+    if (profile == null || profile.username == null) {
+      throw new TypeError("The bot profile with a username is required.");
+    }
+    const bot = new BotImpl<TContextData>({
+      instance: this,
+      identifier: identifierOrDispatcher,
+      kv: this.kv,
+      class: profile.class,
+      username: profile.username,
+      name: profile.name,
+      summary: profile.summary,
+      icon: profile.icon,
+      image: profile.image,
+      properties: profile.properties,
+      followerPolicy: profile.followerPolicy,
+    });
+    return wrapBotImpl(bot);
+  }
+
+  /**
+   * Resolves a bot hosted on the instance by its username, including
+   * dynamically resolved bots.
+   * @param ctx The Fedify context of the resolution.
+   * @param username The username of the bot to resolve.
+   * @returns The resolved bot, or `null` if no bot has the username.
+   */
+  async resolveBotByUsername(
+    ctx: Context<TContextData>,
+    username: string,
+  ): Promise<BotImpl<TContextData> | null> {
+    const identifier = await this.mapHandle(ctx, username);
+    if (identifier == null) return null;
+    return await this.resolveBot(ctx, identifier);
+  }
+
+  async mapHandle(
+    ctx: Context<TContextData>,
+    username: string,
+  ): Promise<string | null> {
+    // WebFinger lookups and profile page visits vary in casing, so static
+    // usernames are matched case-insensitively:
+    const normalized = username.toLowerCase();
+    for (const bot of this.#bots.values()) {
+      if (bot.username.toLowerCase() === normalized) return bot.identifier;
+    }
+    for (const group of this.#groups) {
+      if (group.mapUsername == null) continue;
+      const identifier = await group.mapUsername(ctx, username);
+      if (identifier == null) continue;
+      // The mapping must resolve to a bot of the very group that mapped it;
+      // otherwise a group could hijack usernames of other bots:
+      const bot = await this.resolveBot(ctx, identifier);
+      if (bot instanceof GroupBotImpl && bot.group === group) {
+        return identifier;
+      }
+    }
+    // Unless a group maps usernames explicitly, usernames are assumed to
+    // equal identifiers.  The fallback applies only to dynamic groups
+    // without a mapUsername; a static bot's internal identifier is not
+    // a public username:
+    const bot = await this.resolveBot(ctx, username);
+    if (bot instanceof GroupBotImpl && bot.group.mapUsername == null) {
+      return username;
+    }
+    return null;
+  }
+
+  onUnverifiedActivity(
+    _ctx: Context<TContextData>,
+    activity: Activity,
+    reason: { type: string; result?: unknown },
+  ): Response | void {
+    if (
+      activity instanceof Delete &&
+      reason.type === "keyFetchError" &&
+      typeof reason.result === "object" && reason.result != null &&
+      "status" in reason.result &&
+      reason.result.status === 410
+    ) {
+      return new Response(null, { status: 202 });
+    }
+  }
+
+  /**
+   * Resolves which bots an incoming shared-inbox activity is relevant to.
+   * On a compatible (single-bot) instance every hosted bot is returned,
+   * preserving the pre-0.5 behavior.  A personal-inbox delivery targets
+   * its recipient only.  Otherwise the given resolver computes the
+   * relevant bot identifiers.
+   */
+  async #resolveTargets(
+    ctx: InboxContext<TContextData>,
+    resolve: () =>
+      | Promise<Iterable<string>>
+      | Iterable<string>,
+  ): Promise<BotImpl<TContextData>[]> {
+    if (this.compatMode) return [...this.#bots.values()];
+    if (ctx.recipient != null) {
+      const bot = await this.resolveBot(ctx, ctx.recipient);
+      return bot == null ? [] : [bot];
+    }
+    const identifiers = new Set(await resolve());
+    const bots: BotImpl<TContextData>[] = [];
+    for (const identifier of identifiers) {
+      const bot = await this.resolveBot(ctx, identifier);
+      if (bot != null) bots.push(bot);
+    }
+    return bots;
+  }
+
+  /**
+   * Attributes a local object URI to its owning bot identifier, or logs and
+   * yields nothing when the URI is not a local object.  Activities on
+   * objects the instance does not own cannot be attributed to any bot on
+   * a multi-bot instance, so they are dropped.
+   */
+  #localObjectTarget(
+    ctx: InboxContext<TContextData>,
+    uri: URL | null,
+  ): Iterable<string> {
+    const parsed = parseLocalUri(ctx, uri, this.legacyObjectUrisIdentifier);
+    if (
+      parsed?.type === "object" &&
+      typeof parsed.values.identifier === "string"
+    ) {
+      return [parsed.values.identifier];
+    }
+    const logger = getLogger(["botkit", "instance", "inbox"]);
+    logger.debug(
+      "The object {uri} is not owned by any bot on this instance; " +
+        "the activity is not routed.",
+      { uri: uri?.href },
+    );
+    return [];
+  }
+
+  async onFollowed(
+    ctx: InboxContext<TContextData>,
+    follow: Follow,
+  ): Promise<void> {
+    const bots = await this.#resolveTargets(ctx, () => {
+      const parsed = ctx.parseUri(follow.objectId);
+      return parsed?.type === "actor" ? [parsed.identifier] : [];
+    });
+    for (const bot of bots) await bot.onFollowed(ctx, follow);
+  }
+
+  async onUndone(
+    ctx: InboxContext<TContextData>,
+    undo: Undo,
+  ): Promise<void> {
+    const object = await undo.getObject(ctx);
+    if (object instanceof Follow) {
+      const bots = await this.#resolveTargets(ctx, () => {
+        const parsed = ctx.parseUri(object.objectId);
+        return parsed?.type === "actor" ? [parsed.identifier] : [];
+      });
+      for (const bot of bots) await bot.onUnfollowed(ctx, undo);
+    } else if (object instanceof RawLike) {
+      const bots = await this.#resolveTargets(
+        ctx,
+        () => this.#localObjectTarget(ctx, object.objectId),
+      );
+      for (const bot of bots) await bot.onUnliked(ctx, undo);
+    } else {
+      const logger = getLogger(["botkit", "bot", "inbox"]);
+      logger.warn(
+        "The Undo object {undoId} is not about Follow or Like: {object}.",
+        { undoId: undo.id?.href, object },
+      );
+    }
+  }
+
+  async onFollowAccepted(
+    ctx: InboxContext<TContextData>,
+    accept: Accept,
+  ): Promise<void> {
+    const bots = await this.#resolveTargets(
+      ctx,
+      () => this.#localObjectTarget(ctx, accept.objectId),
+    );
+    for (const bot of bots) await bot.onFollowAccepted(ctx, accept);
+  }
+
+  async onFollowRejected(
+    ctx: InboxContext<TContextData>,
+    reject: Reject,
+  ): Promise<void> {
+    const bots = await this.#resolveTargets(
+      ctx,
+      () => this.#localObjectTarget(ctx, reject.objectId),
+    );
+    for (const bot of bots) await bot.onFollowRejected(ctx, reject);
+  }
+
+  async onLiked(
+    ctx: InboxContext<TContextData>,
+    like: RawLike,
+  ): Promise<void> {
+    const bots = await this.#resolveTargets(
+      ctx,
+      () => this.#localObjectTarget(ctx, like.objectId),
+    );
+    for (const bot of bots) await bot.onLiked(ctx, like);
+  }
+
+  async onCreated(
+    ctx: InboxContext<TContextData>,
+    create: Create,
+  ): Promise<void> {
+    const bots = await this.#resolveTargets(ctx, async () => {
+      const targets = new Set<string>();
+      // Bots following the author see the message on their timeline:
+      if (create.actorId != null) {
+        for await (
+          const identifier of this.repository.findFollowedBots(create.actorId)
+        ) {
+          targets.add(identifier);
+        }
+      }
+      // Bots addressed directly, or whose followers collection is
+      // addressed (either on the activity or on the embedded object):
+      const addAddressee = (uri: URL) => {
+        const parsed = ctx.parseUri(uri);
+        if (parsed?.type === "actor" || parsed?.type === "followers") {
+          if (parsed.identifier != null) targets.add(parsed.identifier);
+        }
+      };
+      for (const uri of [...create.toIds, ...create.ccIds]) {
+        addAddressee(uri);
+      }
+      const addLocalObject = (uri: URL | null) => {
+        const parsed = parseLocalUri(
+          ctx,
+          uri,
+          this.legacyObjectUrisIdentifier,
+        );
+        if (
+          parsed?.type === "object" &&
+          typeof parsed.values.identifier === "string"
+        ) {
+          targets.add(parsed.values.identifier);
+        }
+      };
+      const object = await create.getObject(ctx);
+      if (isMessageObject(object)) {
+        for (const uri of [...object.toIds, ...object.ccIds]) {
+          addAddressee(uri);
+        }
+        // Bots mentioned in or quoted by the message:
+        for await (const tag of object.getTags(ctx)) {
+          if (tag instanceof Mention && tag.href != null) {
+            const parsed = ctx.parseUri(tag.href);
+            if (parsed?.type === "actor") targets.add(parsed.identifier);
+          } else if (tag instanceof Link && isQuoteLink(tag)) {
+            addLocalObject(tag.href);
+          }
+        }
+        addLocalObject(object.quoteUrl);
+        // Bots whose message is replied to:
+        addLocalObject(object.replyTargetId);
+      }
+      return targets;
+    });
+    for (const bot of bots) await bot.onCreated(ctx, create);
+  }
+
+  async onAnnounced(
+    ctx: InboxContext<TContextData>,
+    announce: Announce,
+  ): Promise<void> {
+    const bots = await this.#resolveTargets(ctx, async () => {
+      const targets = new Set<string>();
+      // Bots following the sharer see the share on their timeline:
+      if (announce.actorId != null) {
+        for await (
+          const identifier of this.repository.findFollowedBots(
+            announce.actorId,
+          )
+        ) {
+          targets.add(identifier);
+        }
+      }
+      // Bots addressed directly, or whose followers collection is
+      // addressed, or whose message is shared:
+      for (const uri of [...announce.toIds, ...announce.ccIds]) {
+        const parsed = ctx.parseUri(uri);
+        if (parsed?.type === "actor" || parsed?.type === "followers") {
+          if (parsed.identifier != null) targets.add(parsed.identifier);
+        }
+      }
+      const parsedObject = parseLocalUri(
+        ctx,
+        announce.objectId,
+        this.legacyObjectUrisIdentifier,
+      );
+      if (
+        parsedObject?.type === "object" &&
+        typeof parsedObject.values.identifier === "string"
+      ) {
+        targets.add(parsedObject.values.identifier);
+      }
+      return targets;
+    });
+    for (const bot of bots) await bot.onAnnounced(ctx, announce);
+  }
+
+  dispatchSharedKey(_ctx: Context<TContextData>): { identifier: string } {
+    if (this.compatMode) {
+      const bot = this.#firstBot();
+      if (bot == null) {
+        throw new TypeError(
+          "The instance has no bots; the shared inbox key cannot be " +
+            "dispatched.",
+        );
+      }
+      return { identifier: bot.identifier };
+    }
+    return { identifier: this.instanceActorIdentifier };
+  }
+
+  async #dispatchInstanceActor(
+    ctx: Context<TContextData>,
+  ): Promise<Actor> {
+    const keyPairs = await ctx.getActorKeyPairs(this.instanceActorIdentifier);
+    return new Application({
+      id: ctx.getActorUri(this.instanceActorIdentifier),
+      preferredUsername: this.instanceActorIdentifier,
+      name: "Instance actor",
+      summary: "An internal actor the instance uses for signing requests " +
+        "on behalf of the whole instance.",
+      inbox: ctx.getInboxUri(this.instanceActorIdentifier),
+      endpoints: new Endpoints({
+        sharedInbox: ctx.getInboxUri(),
+      }),
+      publicKey: keyPairs[0].cryptographicKey,
+      assertionMethods: keyPairs.map((pair) => pair.multikey),
+      discoverable: false,
+    });
+  }
+
+  #instanceActorKeyPairs?: Promise<CryptoKeyPair[]>;
+
+  #dispatchInstanceActorKeyPairs(): Promise<CryptoKeyPair[]> {
+    // Concurrent cold-start requests must not generate competing key pairs
+    // and overwrite each other, so the whole load-or-generate sequence is
+    // memoized in process:
+    if (this.#instanceActorKeyPairs != null) {
+      return this.#instanceActorKeyPairs;
+    }
+    const promise = (async () => {
+      let keyPairs = await this.repository.getKeyPairs(
+        this.instanceActorIdentifier,
+      );
+      if (keyPairs == null) {
+        const rsa = await generateCryptoKeyPair("RSASSA-PKCS1-v1_5");
+        const ed25519 = await generateCryptoKeyPair("Ed25519");
+        keyPairs = [rsa, ed25519];
+        await this.repository.setKeyPairs(
+          this.instanceActorIdentifier,
+          keyPairs,
+        );
+      }
+      return keyPairs;
+    })();
+    this.#instanceActorKeyPairs = promise;
+    // A failed attempt (e.g. a transient storage error) must not be cached
+    // forever:
+    promise.catch(() => {
+      if (this.#instanceActorKeyPairs === promise) {
+        this.#instanceActorKeyPairs = undefined;
+      }
+    });
+    return promise;
+  }
+
+  dispatchNodeInfo(_ctx: Context<TContextData>): NodeInfo {
+    return {
+      software: this.software!,
+      protocols: ["activitypub"],
+      services: {
+        outbound: ["atom1.0"], // TODO
+      },
+      usage: {
+        users: {
+          total: this.botCount,
+          activeMonth: this.botCount, // FIXME
+          activeHalfyear: this.botCount, // FIXME
+        },
+        localPosts: 0, // FIXME
+        localComments: 0,
+      },
+    };
+  }
+
+  dispatchEmoji(
+    ctx: Context<TContextData>,
+    values: { name: string },
+  ): APEmoji | null {
+    const customEmoji = this.customEmojis[values.name];
+    if (customEmoji == null) return null;
+    return this.getEmoji(ctx, values.name, customEmoji);
+  }
+
+  getEmoji(
+    ctx: Context<TContextData>,
+    name: string,
+    data: CustomEmoji,
+  ): APEmoji {
+    let url: URL;
+    if ("url" in data) {
+      url = new URL(data.url);
+    } else {
+      // @ts-ignore: data.type satisfies keyof typeof mimeDb
+      const t = mimeDb[data.type];
+      url = new URL(
+        `/emojis/${name}${
+          t == null || t.extensions == null || t.extensions.length < 1
+            ? ""
+            : `.${t.extensions[0]}`
+        }`,
+        ctx.origin,
+      );
+    }
+    return new APEmoji({
+      id: ctx.getObjectUri(APEmoji, { name }),
+      name: `:${name}:`,
+      icon: new Image({
+        mediaType: data.type,
+        url,
+      }),
+    });
+  }
+
+  addCustomEmoji<TEmojiName extends string>(
+    name: TEmojiName,
+    data: CustomEmoji,
+  ): DeferredCustomEmoji<TContextData> {
+    if (!name.match(/^[a-z0-9-_]+$/i)) {
+      throw new TypeError(
+        `Invalid custom emoji name: ${name}. It must match /^[a-z0-9-_]+$/i.`,
+      );
+    } else if (name in this.customEmojis) {
+      throw new TypeError(`Duplicate custom emoji name: ${name}`);
+    } else if (!data.type.startsWith("image/")) {
+      throw new TypeError(`Unsupported media type: ${data.type}`);
+    }
+    this.customEmojis[name] = data;
+    return (session: Session<TContextData>) =>
+      this.getEmoji(
+        session.context,
+        name,
+        data,
+      );
+  }
+
+  addCustomEmojis<TEmojiName extends string>(
+    emojis: Readonly<Record<TEmojiName, CustomEmoji>>,
+  ): Readonly<Record<TEmojiName, DeferredCustomEmoji<TContextData>>> {
+    const emojiMap = {} as Record<
+      TEmojiName,
+      DeferredCustomEmoji<TContextData>
+    >;
+    for (const name in emojis) {
+      emojiMap[name] = this.addCustomEmoji(name, emojis[name]);
+    }
+    return emojiMap;
+  }
+
+  async addCollectionInverseProperty(
+    request: Request,
+    contextData: TContextData,
+    response: Response,
+  ): Promise<Response> {
+    if (!response.ok) return response;
+    const ctx = this.federation.createContext(request, contextData);
+    const parsed = ctx.parseUri(new URL(request.url));
+    if (
+      parsed == null ||
+      (parsed.type !== "outbox" && parsed.type !== "followers") ||
+      parsed.identifier == null
+    ) {
+      return response;
+    }
+    const contentType = response.headers.get("Content-Type");
+    if (
+      contentType == null ||
+      (
+        !contentType.startsWith("application/activity+json") &&
+        !contentType.startsWith("application/ld+json")
+      )
+    ) {
+      return response;
+    }
+    const body = await response.json();
+    if (typeof body !== "object" || body == null || Array.isArray(body)) {
+      return new Response(JSON.stringify(body), {
+        headers: response.headers,
+        status: response.status,
+        statusText: response.statusText,
+      });
+    }
+    const property = parsed.type === "outbox" ? "outboxOf" : "followersOf";
+    const actorUri = ctx.getActorUri(parsed.identifier).href;
+    if (body[property] === actorUri) {
+      return new Response(JSON.stringify(body), {
+        headers: response.headers,
+        status: response.status,
+        statusText: response.statusText,
+      });
+    }
+    const headers = new Headers(response.headers);
+    headers.delete("Content-Length");
+    return new Response(JSON.stringify({ ...body, [property]: actorUri }), {
+      headers,
+      status: response.status,
+      statusText: response.statusText,
+    });
+  }
+
+  async fetch(request: Request, contextData: TContextData): Promise<Response> {
+    if (this.behindProxy) {
+      request = await getXForwardedRequest(request);
+    }
+    const url = new URL(request.url);
+    if (
+      (request.method === "GET" || request.method === "HEAD") &&
+      this.legacyObjectUrisIdentifier != null
+    ) {
+      // Dereferenceable requests to object URIs in the legacy (pre-0.5)
+      // format are permanently redirected to their canonical URIs:
+      const rewrittenPath = rewriteLegacyObjectPath(
+        url.pathname,
+        this.legacyObjectUrisIdentifier,
+      );
+      if (rewrittenPath != null) {
+        const location = new URL(url.href);
+        location.pathname = rewrittenPath;
+        return new Response(null, {
+          status: 301,
+          headers: { Location: location.href },
+        });
+      }
+    }
+    if (
+      url.pathname.startsWith("/.well-known/") ||
+      url.pathname.startsWith("/ap/") ||
+      url.pathname.startsWith("/nodeinfo/")
+    ) {
+      const response = await this.federation.fetch(request, { contextData });
+      return await this.addCollectionInverseProperty(
+        request,
+        contextData,
+        response,
+      );
+    }
+    const match = /^\/emojis\/([a-z0-9-_]+)(?:$|\.)/.exec(url.pathname);
+    if (match != null) {
+      const customEmoji = this.customEmojis[match[1]];
+      if (customEmoji == null || !("file" in customEmoji)) {
+        return new Response("Not Found", { status: 404 });
+      }
+      // Custom emojis are small images, so reading them into memory avoids
+      // managing a file handle whose readableWebStream() does not close it
+      // on completion (leaking a descriptor per request):
+      let fileInfo: Awaited<ReturnType<typeof fs.stat>>;
+      let data: Uint8Array;
+      try {
+        fileInfo = await fs.stat(customEmoji.file);
+        data = await fs.readFile(customEmoji.file);
+      } catch (error) {
+        if (
+          typeof error === "object" && error != null && "code" in error &&
+          error.code === "ENOENT"
+        ) {
+          return new Response("Not Found", { status: 404 });
+        }
+        throw error;
+      }
+      const mtime = fileInfo.mtime ?? new Date();
+      return new Response(data as Uint8Array<ArrayBuffer>, {
+        headers: {
+          "Content-Type": customEmoji.type,
+          "Content-Length": fileInfo.size.toString(),
+          "Cache-Control": "public, max-age=31536000, immutable",
+          "Last-Modified": mtime.toUTCString(),
+          "ETag": `"${mtime.getTime().toString(36)}${
+            fileInfo.size.toString(36)
+          }"`,
+        },
+      });
+    }
+    if (this.compatMode) {
+      const bot = this.#firstBot();
+      if (bot == null) return new Response("Not Found", { status: 404 });
+      return await app.fetch(request, { bot, contextData });
+    }
+    return await multiApp.fetch(request, {
+      instance: this as InstanceImpl<unknown>,
+      contextData,
+    });
+  }
+
+  /**
+   * The web page URL of a bot hosted on the instance.  A compatible
+   * (single-bot) instance serves its bot at the web root; a multi-bot
+   * instance serves each bot under a path derived from its username.
+   * @param bot The bot to get the web page URL of.
+   * @param origin The origin of the URL.
+   * @returns The web page URL of the bot.
+   */
+  getBotWebUrl(bot: BotImpl<TContextData>, origin: string | URL): URL {
+    return new URL(
+      this.compatMode ? "/" : `/@${encodeURIComponent(bot.username)}`,
+      origin,
+    );
+  }
+
+  /**
+   * The web permalink of a message published by a bot hosted on
+   * the instance.
+   * @param bot The bot that published the message.
+   * @param id The UUID of the message.
+   * @param origin The origin of the URL.
+   * @returns The web permalink of the message.
+   */
+  getMessageWebUrl(
+    bot: BotImpl<TContextData>,
+    id: string,
+    origin: string | URL,
+  ): URL {
+    return new URL(
+      this.compatMode
+        ? `/message/${id}`
+        : `/@${encodeURIComponent(bot.username)}/${id}`,
+      origin,
+    );
+  }
+}
diff --git a/packages/botkit/src/instance-multi.test.ts b/packages/botkit/src/instance-multi.test.ts
new file mode 100644
index 0000000..42fd0b2
--- /dev/null
+++ b/packages/botkit/src/instance-multi.test.ts
@@ -0,0 +1,263 @@
+// BotKit by Fedify: A framework for creating ActivityPub bots
+// Copyright (C) 2025–2026 Hong Minhee <https://hongminhee.org/>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+import { MemoryKvStore } from "@fedify/fedify/federation";
+import { Create, Note, PUBLIC_COLLECTION } from "@fedify/vocab";
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import {
+  createInstance,
+  DEFAULT_INSTANCE_ACTOR_IDENTIFIER,
+  type InstanceWithVoidContextData,
+} from "./instance.ts";
+import type { InstanceImpl } from "./instance-impl.ts";
+import { MemoryRepository, type Uuid } from "./repository.ts";
+
+function fetchJson(
+  instance: InstanceWithVoidContextData,
+  url: string,
+  // deno-lint-ignore no-explicit-any
+): Promise<any> {
+  return instance.fetch(
+    new Request(url, { headers: { Accept: "application/activity+json" } }),
+  ).then(async (response) => {
+    assert.deepStrictEqual(response.status, 200, `GET ${url}`);
+    return await response.json();
+  });
+}
+
+describe("multiple static bots", () => {
+  test("serves distinct actors and collections", async () => {
+    const instance = createInstance<void>({ kv: new MemoryKvStore() });
+    instance.createBot("alpha", { username: "alphabot", name: "Alpha" });
+    instance.createBot("beta", { username: "betabot", name: "Beta" });
+
+    const alpha = await fetchJson(
+      instance,
+      "https://example.com/ap/actor/alpha",
+    );
+    const beta = await fetchJson(instance, "https://example.com/ap/actor/beta");
+    assert.deepStrictEqual(alpha.preferredUsername, "alphabot");
+    assert.deepStrictEqual(beta.preferredUsername, "betabot");
+    assert.notDeepStrictEqual(alpha.id, beta.id);
+    assert.notDeepStrictEqual(alpha.followers, beta.followers);
+    assert.notDeepStrictEqual(alpha.outbox, beta.outbox);
+  });
+
+  test("resolves each username through WebFinger", async () => {
+    const instance = createInstance<void>({ kv: new MemoryKvStore() });
+    instance.createBot("alpha", { username: "alphabot" });
+    instance.createBot("beta", { username: "betabot" });
+
+    for (
+      const [username, identifier] of [
+        ["alphabot", "alpha"],
+        ["betabot", "beta"],
+      ]
+    ) {
+      const response = await instance.fetch(
+        new Request(
+          `https://example.com/.well-known/webfinger?resource=acct:${username}@example.com`,
+        ),
+      );
+      assert.deepStrictEqual(response.status, 200);
+      const jrd = await response.json();
+      const self = jrd.links.find((link: { rel: string }) =>
+        link.rel === "self"
+      );
+      assert.deepStrictEqual(
+        self.href,
+        `https://example.com/ap/actor/${identifier}`,
+      );
+    }
+  });
+
+  test("does not serve one bot's objects under another bot's path", async () => {
+    const repository = new MemoryRepository();
+    const instance = createInstance<void>({
+      kv: new MemoryKvStore(),
+      repository,
+    });
+    instance.createBot("alpha", { username: "alphabot" });
+    instance.createBot("beta", { username: "betabot" });
+
+    const messageId: Uuid = "01941f29-7c00-7fe8-ab0a-7b593990a3c0";
+    await repository.addMessage(
+      "alpha",
+      messageId,
+      new Create({
+        id: new URL(
+          `https://example.com/ap/actor/alpha/create/${messageId}`,
+        ),
+        actor: new URL("https://example.com/ap/actor/alpha"),
+        to: PUBLIC_COLLECTION,
+        object: new Note({
+          id: new URL(`https://example.com/ap/actor/alpha/note/${messageId}`),
+          attribution: new URL("https://example.com/ap/actor/alpha"),
+          to: PUBLIC_COLLECTION,
+          content: "Hello from alpha!",
+        }),
+      }),
+    );
+
+    const own = await instance.fetch(
+      new Request(
+        `https://example.com/ap/actor/alpha/note/${messageId}`,
+        { headers: { Accept: "application/activity+json" } },
+      ),
+    );
+    assert.deepStrictEqual(own.status, 200);
+
+    // The same UUID under beta's path must not leak alpha's message:
+    const cross = await instance.fetch(
+      new Request(
+        `https://example.com/ap/actor/beta/note/${messageId}`,
+        { headers: { Accept: "application/activity+json" } },
+      ),
+    );
+    assert.deepStrictEqual(cross.status, 404);
+  });
+});
+
+describe("instance actor", () => {
+  test("is served under the reserved identifier", async () => {
+    const instance = createInstance<void>({ kv: new MemoryKvStore() });
+    instance.createBot("alpha", { username: "alphabot" });
+    const actor = await fetchJson(
+      instance,
+      `https://example.com/ap/actor/${DEFAULT_INSTANCE_ACTOR_IDENTIFIER}`,
+    );
+    assert.deepStrictEqual(actor.type, "Application");
+    assert.ok(actor.publicKey != null);
+  });
+
+  test("signs the shared inbox on multi-bot instances", () => {
+    const instance = createInstance<void>({ kv: new MemoryKvStore() });
+    instance.createBot("alpha", { username: "alphabot" });
+    const impl = (instance as unknown as {
+      impl: {
+        dispatchSharedKey(ctx: unknown): { identifier: string };
+        federation: {
+          createContext(url: URL): unknown;
+        };
+      };
+    }).impl;
+    const ctx = impl.federation.createContext(new URL("https://example.com/"));
+    assert.deepStrictEqual(impl.dispatchSharedKey(ctx), {
+      identifier: DEFAULT_INSTANCE_ACTOR_IDENTIFIER,
+    });
+  });
+
+  test("cannot be taken by a bot", async () => {
+    const instance = createInstance<void>({ kv: new MemoryKvStore() });
+    assert.throws(
+      () =>
+        instance.createBot(DEFAULT_INSTANCE_ACTOR_IDENTIFIER, {
+          username: "sneaky",
+        }),
+      TypeError,
+    );
+
+    // Dynamic dispatchers cannot take the reserved identifier either:
+    instance.createBot((_ctx, identifier) => ({ username: identifier }));
+    const response = await instance.fetch(
+      new Request(
+        `https://example.com/ap/actor/${DEFAULT_INSTANCE_ACTOR_IDENTIFIER}`,
+        { headers: { Accept: "application/activity+json" } },
+      ),
+    );
+    assert.deepStrictEqual(response.status, 200);
+    const actor = await response.json();
+    assert.deepStrictEqual(actor.type, "Application");
+  });
+
+  test("can be renamed through instanceActorIdentifier", async () => {
+    const instance = createInstance<void>({
+      kv: new MemoryKvStore(),
+      instanceActorIdentifier: "fetcher",
+    });
+    instance.createBot("alpha", { username: "alphabot" });
+
+    const actor = await fetchJson(
+      instance,
+      "https://example.com/ap/actor/fetcher",
+    );
+    assert.deepStrictEqual(actor.type, "Application");
+    assert.deepStrictEqual(actor.preferredUsername, "fetcher");
+
+    // The custom identifier is the reserved one now:
+    assert.throws(
+      () => instance.createBot("fetcher", { username: "other" }),
+      TypeError,
+    );
+    // ...and the default identifier is free for bots:
+    const bot = instance.createBot(DEFAULT_INSTANCE_ACTOR_IDENTIFIER, {
+      username: "underscores",
+    });
+    assert.deepStrictEqual(bot.identifier, DEFAULT_INSTANCE_ACTOR_IDENTIFIER);
+  });
+});
+
+describe("instance actor key pairs", () => {
+  test("are generated once under concurrency", async () => {
+    const repository = new MemoryRepository();
+    const instance = createInstance<void>({
+      kv: new MemoryKvStore(),
+      repository,
+    });
+    instance.createBot("alpha", { username: "alphabot" });
+    const impl = (instance as unknown as {
+      impl: InstanceImpl<void>;
+    }).impl;
+    // Simulates concurrent cold-start requests hitting the key pair
+    // dispatcher at once:
+    const responses = await Promise.all(
+      Array.from({ length: 4 }, () =>
+        instance.fetch(
+          new Request(
+            `https://example.com/ap/actor/${DEFAULT_INSTANCE_ACTOR_IDENTIFIER}`,
+            { headers: { Accept: "application/activity+json" } },
+          ),
+        )),
+    );
+    const actors = await Promise.all(responses.map((r) => r.json()));
+    const keyIds = new Set(
+      actors.map((actor) => JSON.stringify(actor.publicKey)),
+    );
+    // Every response advertises the same key, and the stored key matches:
+    assert.deepStrictEqual(keyIds.size, 1);
+    const stored = await repository.getKeyPairs(
+      impl.instanceActorIdentifier,
+    );
+    assert.ok(stored != null);
+  });
+});
+
+describe("NodeInfo on multi-bot instances", () => {
+  test("counts the hosted bots", async () => {
+    const instance = createInstance<void>({
+      kv: new MemoryKvStore(),
+      software: { name: "test-bot", version: "1.0.0" },
+    });
+    instance.createBot("alpha", { username: "alphabot" });
+    instance.createBot("beta", { username: "betabot" });
+    const response = await instance.fetch(
+      new Request("https://example.com/nodeinfo/2.1"),
+    );
+    assert.deepStrictEqual(response.status, 200);
+    const nodeInfo = await response.json();
+    assert.deepStrictEqual(nodeInfo.usage.users.total, 2);
+  });
+});
diff --git a/packages/botkit/src/instance-routing.test.ts b/packages/botkit/src/instance-routing.test.ts
new file mode 100644
index 0000000..88a0180
--- /dev/null
+++ b/packages/botkit/src/instance-routing.test.ts
@@ -0,0 +1,551 @@
+// BotKit by Fedify: A framework for creating ActivityPub bots
+// Copyright (C) 2025–2026 Hong Minhee <https://hongminhee.org/>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+import { type InboxContext, MemoryKvStore } from "@fedify/fedify/federation";
+import {
+  Accept,
+  Create,
+  Follow,
+  Like as RawLike,
+  Mention,
+  Note,
+  Person,
+  PUBLIC_COLLECTION,
+  Undo,
+} from "@fedify/vocab";
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import type { Bot } from "./bot.ts";
+import { BotImpl } from "./bot-impl.ts";
+import { InstanceImpl } from "./instance-impl.ts";
+import { MemoryRepository, type Uuid } from "./repository.ts";
+
+function createMockInboxContext<TContextData>(
+  instance: InstanceImpl<TContextData>,
+  origin: string | URL,
+  contextData: TContextData,
+  recipient?: string | null,
+): InboxContext<TContextData> {
+  const ctx = instance.federation.createContext(
+    new URL(origin),
+    contextData,
+  ) as InboxContext<TContextData>;
+  Object.defineProperty(ctx, "recipient", {
+    value: recipient ?? null,
+    writable: true,
+    configurable: true,
+  });
+  Object.defineProperty(ctx, "sendActivity", {
+    value: () => Promise.resolve(),
+    writable: true,
+    configurable: true,
+  });
+  Object.defineProperty(ctx, "forwardActivity", {
+    value: () => Promise.resolve(),
+    writable: true,
+    configurable: true,
+  });
+  return ctx;
+}
+
+interface Harness {
+  readonly instance: InstanceImpl<void>;
+  readonly repository: MemoryRepository;
+  readonly alpha: Bot<void>;
+  readonly beta: Bot<void>;
+  readonly ctx: InboxContext<void>;
+}
+
+function createHarness(): Harness {
+  const repository = new MemoryRepository();
+  const instance = new InstanceImpl<void>({
+    kv: new MemoryKvStore(),
+    repository,
+  });
+  const alpha = instance.createBot("alpha", { username: "alphabot" });
+  const beta = instance.createBot("beta", { username: "betabot" });
+  const ctx = createMockInboxContext(
+    instance,
+    "https://example.com/",
+    undefined,
+  );
+  return { instance, repository, alpha, beta, ctx };
+}
+
+function remotePerson(handle: string): Person {
+  return new Person({
+    id: new URL(`https://example.com/ap/actor/${handle}`),
+    preferredUsername: handle,
+  });
+}
+
+describe("shared inbox routing", () => {
+  test("routes Follow to the followed bot only", async () => {
+    const { instance, alpha, beta, ctx } = createHarness();
+    const followed: string[] = [];
+    alpha.onFollow = (session) => void (followed.push(session.bot.identifier));
+    beta.onFollow = (session) => void (followed.push(session.bot.identifier));
+    await instance.onFollowed(
+      ctx,
+      new Follow({
+        id: new URL("https://remote.example/follows/1"),
+        actor: remotePerson("john"),
+        object: new URL("https://example.com/ap/actor/alpha"),
+      }),
+    );
+    assert.deepStrictEqual(followed, ["alpha"]);
+  });
+
+  test("routes Accept to the bot that sent the follow", async () => {
+    const { instance, repository, alpha, beta, ctx } = createHarness();
+    const accepted: string[] = [];
+    alpha.onAcceptFollow = (session) =>
+      void (accepted.push(session.bot.identifier));
+    beta.onAcceptFollow = (session) =>
+      void (accepted.push(session.bot.identifier));
+    const followId: Uuid = "9d952a10-77e6-46bd-a48a-208b47e5e2bb";
+    await repository.addSentFollow(
+      "alpha",
+      followId,
+      new Follow({
+        id: new URL(
+          `https://example.com/ap/actor/alpha/follow/${followId}`,
+        ),
+        actor: new URL("https://example.com/ap/actor/alpha"),
+        object: remotePerson("john"),
+      }),
+    );
+    await instance.onFollowAccepted(
+      ctx,
+      new Accept({
+        actor: new URL("https://example.com/ap/actor/john"),
+        object: new URL(
+          `https://example.com/ap/actor/alpha/follow/${followId}`,
+        ),
+      }),
+    );
+    assert.deepStrictEqual(accepted, ["alpha"]);
+  });
+
+  test("routes Like to the bot owning the message", async () => {
+    const { instance, repository, alpha, beta, ctx } = createHarness();
+    const liked: string[] = [];
+    alpha.onLike = (session) => void (liked.push(session.bot.identifier));
+    beta.onLike = (session) => void (liked.push(session.bot.identifier));
+    const messageId: Uuid = "01941f29-7c00-7fe8-ab0a-7b593990a3c0";
+    await repository.addMessage(
+      "alpha",
+      messageId,
+      new Create({
+        id: new URL(
+          `https://example.com/ap/actor/alpha/create/${messageId}`,
+        ),
+        actor: new URL("https://example.com/ap/actor/alpha"),
+        to: PUBLIC_COLLECTION,
+        object: new Note({
+          id: new URL(
+            `https://example.com/ap/actor/alpha/note/${messageId}`,
+          ),
+          attribution: new URL("https://example.com/ap/actor/alpha"),
+          to: PUBLIC_COLLECTION,
+          content: "Hello!",
+        }),
+      }),
+    );
+    await instance.onLiked(
+      ctx,
+      new RawLike({
+        id: new URL("https://remote.example/likes/1"),
+        actor: remotePerson("john"),
+        object: new URL(
+          `https://example.com/ap/actor/alpha/note/${messageId}`,
+        ),
+      }),
+    );
+    assert.deepStrictEqual(liked, ["alpha"]);
+  });
+
+  test("drops Like on objects the instance does not own", async () => {
+    const { instance, alpha, beta, ctx } = createHarness();
+    const liked: string[] = [];
+    alpha.onLike = (session) => void (liked.push(session.bot.identifier));
+    beta.onLike = (session) => void (liked.push(session.bot.identifier));
+    await instance.onLiked(
+      ctx,
+      new RawLike({
+        id: new URL("https://remote.example/likes/2"),
+        actor: remotePerson("john"),
+        object: new URL("https://remote.example/notes/1"),
+      }),
+    );
+    assert.deepStrictEqual(liked, []);
+  });
+
+  test("ignores Like on another bot's local object", async () => {
+    const { instance, alpha, beta } = createHarness();
+    const liked: string[] = [];
+    alpha.onLike = (session) => void (liked.push(session.bot.identifier));
+    beta.onLike = (session) => void (liked.push(session.bot.identifier));
+    // Delivered to beta's personal inbox, but the object is alpha's local
+    // note (embedded, so no dereference is needed to see it):
+    const ctx = createMockInboxContext(
+      instance,
+      "https://example.com/",
+      undefined,
+      "beta",
+    );
+    const messageId: Uuid = "01941f29-7c00-7fe8-ab0a-7b593990a3c1";
+    await instance.onLiked(
+      ctx,
+      new RawLike({
+        id: new URL("https://remote.example/likes/4"),
+        actor: remotePerson("john"),
+        object: new Note({
+          id: new URL(
+            `https://example.com/ap/actor/alpha/note/${messageId}`,
+          ),
+          attribution: new URL("https://example.com/ap/actor/alpha"),
+          to: PUBLIC_COLLECTION,
+          content: "Alpha's note",
+        }),
+      }),
+    );
+    assert.deepStrictEqual(liked, []);
+  });
+
+  test("ignores reactions on another bot's local object", async () => {
+    const { instance, alpha, beta } = createHarness();
+    const reacted: string[] = [];
+    alpha.onReact = (session) => void (reacted.push(session.bot.identifier));
+    beta.onReact = (session) => void (reacted.push(session.bot.identifier));
+    const ctx = createMockInboxContext(
+      instance,
+      "https://example.com/",
+      undefined,
+      "beta",
+    );
+    const messageId: Uuid = "01941f29-7c00-7fe8-ab0a-7b593990a3c2";
+    // A Like with a name is treated as an emoji reaction:
+    await instance.onLiked(
+      ctx,
+      new RawLike({
+        id: new URL("https://remote.example/reacts/1"),
+        actor: remotePerson("john"),
+        name: "👍",
+        object: new Note({
+          id: new URL(
+            `https://example.com/ap/actor/alpha/note/${messageId}`,
+          ),
+          attribution: new URL("https://example.com/ap/actor/alpha"),
+          to: PUBLIC_COLLECTION,
+          content: "Alpha's note",
+        }),
+      }),
+    );
+    assert.deepStrictEqual(reacted, []);
+  });
+
+  test("routes Create replies to the replied bot", async () => {
+    const { instance, repository, alpha, beta, ctx } = createHarness();
+    const events: string[] = [];
+    alpha.onReply = (session) =>
+      void (events.push(`reply:${session.bot.identifier}`));
+    beta.onReply = (session) =>
+      void (events.push(`reply:${session.bot.identifier}`));
+    beta.onMessage = (session) =>
+      void (events.push(`message:${session.bot.identifier}`));
+
+    const messageId: Uuid = "01941f29-7c00-7fe8-ab0a-7b593990a3c0";
+    await repository.addMessage(
+      "alpha",
+      messageId,
+      new Create({
+        id: new URL(
+          `https://example.com/ap/actor/alpha/create/${messageId}`,
+        ),
+        actor: new URL("https://example.com/ap/actor/alpha"),
+        to: PUBLIC_COLLECTION,
+        object: new Note({
+          id: new URL(
+            `https://example.com/ap/actor/alpha/note/${messageId}`,
+          ),
+          attribution: new URL("https://example.com/ap/actor/alpha"),
+          to: PUBLIC_COLLECTION,
+          content: "Original post",
+        }),
+      }),
+    );
+
+    const author = remotePerson("john");
+    await instance.onCreated(
+      ctx,
+      new Create({
+        id: new URL("https://remote.example/creates/1"),
+        actor: author,
+        to: PUBLIC_COLLECTION,
+        object: new Note({
+          id: new URL("https://remote.example/notes/1"),
+          attribution: author,
+          to: PUBLIC_COLLECTION,
+          content: "A reply",
+          replyTarget: new URL(
+            `https://example.com/ap/actor/alpha/note/${messageId}`,
+          ),
+        }),
+      }),
+    );
+    assert.deepStrictEqual(events, ["reply:alpha"]);
+  });
+
+  test("routes Create mentions to the mentioned bot", async () => {
+    const { instance, alpha, beta, ctx } = createHarness();
+    const events: string[] = [];
+    alpha.onMention = (session) =>
+      void (events.push(`mention:${session.bot.identifier}`));
+    alpha.onMessage = (session) =>
+      void (events.push(`message:${session.bot.identifier}`));
+    beta.onMention = (session) =>
+      void (events.push(`mention:${session.bot.identifier}`));
+
+    const author = remotePerson("john");
+    await instance.onCreated(
+      ctx,
+      new Create({
+        id: new URL("https://remote.example/creates/2"),
+        actor: author,
+        to: PUBLIC_COLLECTION,
+        object: new Note({
+          id: new URL("https://remote.example/notes/2"),
+          attribution: author,
+          to: PUBLIC_COLLECTION,
+          content: "Hello @betabot!",
+          tags: [
+            new Mention({
+              href: new URL("https://example.com/ap/actor/beta"),
+              name: "@betabot@example.com",
+            }),
+          ],
+        }),
+      }),
+    );
+    assert.deepStrictEqual(events, ["mention:beta"]);
+  });
+
+  test("routes Create to followers of the author", async () => {
+    const { instance, repository, alpha, beta, ctx } = createHarness();
+    const events: string[] = [];
+    alpha.onMessage = (session) =>
+      void (events.push(`message:${session.bot.identifier}`));
+    beta.onMessage = (session) =>
+      void (events.push(`message:${session.bot.identifier}`));
+
+    const author = remotePerson("john");
+    await repository.addFollowee(
+      "alpha",
+      author.id!,
+      new Follow({
+        id: new URL(
+          "https://example.com/ap/actor/alpha/follow/e35ff5d8-ede9-4f5e-9b83-4bfcd4c9a69c",
+        ),
+        actor: new URL("https://example.com/ap/actor/alpha"),
+        object: author.id!,
+      }),
+    );
+    await instance.onCreated(
+      ctx,
+      new Create({
+        id: new URL("https://remote.example/creates/5"),
+        actor: author,
+        to: PUBLIC_COLLECTION,
+        object: new Note({
+          id: new URL("https://remote.example/notes/5"),
+          attribution: author,
+          to: PUBLIC_COLLECTION,
+          content: "Just a timeline post",
+        }),
+      }),
+    );
+    assert.deepStrictEqual(events, ["message:alpha"]);
+  });
+
+  test("routes Undo(Follow) to the unfollowed bot", async () => {
+    const { instance, repository, alpha, beta, ctx } = createHarness();
+    const unfollowed: string[] = [];
+    alpha.onUnfollow = (session) =>
+      void (unfollowed.push(session.bot.identifier));
+    beta.onUnfollow = (session) =>
+      void (unfollowed.push(session.bot.identifier));
+    const follower = remotePerson("john");
+    const followId = new URL("https://remote.example/follows/1");
+    await repository.addFollower("alpha", followId, follower);
+    await instance.onUndone(
+      ctx,
+      new Undo({
+        actor: follower.id,
+        object: new Follow({
+          id: followId,
+          actor: follower.id,
+          object: new URL("https://example.com/ap/actor/alpha"),
+        }),
+      }),
+    );
+    assert.deepStrictEqual(unfollowed, ["alpha"]);
+  });
+
+  test("delivers personal inbox activities to the recipient only", async () => {
+    const repository = new MemoryRepository();
+    const instance = new InstanceImpl<void>({
+      kv: new MemoryKvStore(),
+      repository,
+    });
+    const alpha = instance.createBot("alpha", { username: "alphabot" });
+    const beta = instance.createBot("beta", { username: "betabot" });
+    const events: string[] = [];
+    alpha.onMessage = (session) =>
+      void (events.push(`message:${session.bot.identifier}`));
+    beta.onMessage = (session) =>
+      void (events.push(`message:${session.bot.identifier}`));
+    const ctx = createMockInboxContext(
+      instance,
+      "https://example.com/",
+      undefined,
+      "beta",
+    );
+    const author = remotePerson("john");
+    await instance.onCreated(
+      ctx,
+      new Create({
+        id: new URL("https://remote.example/creates/3"),
+        actor: author,
+        to: PUBLIC_COLLECTION,
+        object: new Note({
+          id: new URL("https://remote.example/notes/3"),
+          attribution: author,
+          to: PUBLIC_COLLECTION,
+          content: "Delivered to beta's personal inbox",
+        }),
+      }),
+    );
+    assert.deepStrictEqual(events, ["message:beta"]);
+  });
+});
+
+describe("compatible single-bot instances", () => {
+  test("fire onMessage for any incoming Create", async () => {
+    const bot = new BotImpl<void>({
+      kv: new MemoryKvStore(),
+      repository: new MemoryRepository(),
+      username: "bot",
+    });
+    const events: string[] = [];
+    bot.onMessage = (session) =>
+      void (events.push(`message:${session.bot.identifier}`));
+    const ctx = createMockInboxContext(
+      bot.instance,
+      "https://example.com/",
+      undefined,
+    );
+    const author = remotePerson("john");
+    // The bot does not follow the author and is not addressed, but the
+    // pre-0.5 behavior of a single-bot deployment is preserved:
+    await bot.instance.onCreated(
+      ctx,
+      new Create({
+        id: new URL("https://remote.example/creates/4"),
+        actor: author,
+        to: PUBLIC_COLLECTION,
+        object: new Note({
+          id: new URL("https://remote.example/notes/4"),
+          attribution: author,
+          to: PUBLIC_COLLECTION,
+          content: "Unrelated post",
+        }),
+      }),
+    );
+    assert.deepStrictEqual(events, ["message:bot"]);
+  });
+
+  test("fire onLike for likes of objects with foreign URIs", async () => {
+    const bot = new BotImpl<void>({
+      kv: new MemoryKvStore(),
+      repository: new MemoryRepository(),
+      username: "bot",
+    });
+    const events: string[] = [];
+    bot.onLike = (session) => void (events.push(session.bot.identifier));
+    const ctx = createMockInboxContext(
+      bot.instance,
+      "https://example.com/",
+      undefined,
+    );
+    await bot.instance.onLiked(
+      ctx,
+      new RawLike({
+        id: new URL("https://remote.example/likes/3"),
+        actor: new Person({
+          id: new URL("https://example.com/ap/actor/bot"),
+          preferredUsername: "bot",
+        }),
+        object: new Note({
+          id: new URL("https://remote.example/notes/5"),
+          attribution: new URL("https://example.com/ap/actor/bot"),
+          to: PUBLIC_COLLECTION,
+          content: "A note with a foreign URI",
+        }),
+      }),
+    );
+    assert.deepStrictEqual(events, ["bot"]);
+  });
+});
+
+describe("addressed Create routing", () => {
+  test("routes by the embedded object's addressing", async () => {
+    const repository = new MemoryRepository();
+    const instance = new InstanceImpl<void>({
+      kv: new MemoryKvStore(),
+      repository,
+    });
+    const alpha = instance.createBot("alpha", { username: "alphabot" });
+    const beta = instance.createBot("beta", { username: "betabot" });
+    const events: string[] = [];
+    alpha.onMessage = (session) =>
+      void (events.push(`message:${session.bot.identifier}`));
+    beta.onMessage = (session) =>
+      void (events.push(`message:${session.bot.identifier}`));
+    const ctx = createMockInboxContext(
+      instance,
+      "https://example.com/",
+      undefined,
+    );
+    const author = remotePerson("john");
+    // The activity wrapper is public only; the audience is on the object:
+    await instance.onCreated(
+      ctx,
+      new Create({
+        id: new URL("https://remote.example/creates/6"),
+        actor: author,
+        to: PUBLIC_COLLECTION,
+        object: new Note({
+          id: new URL("https://remote.example/notes/6"),
+          attribution: author,
+          to: new URL("https://example.com/ap/actor/beta"),
+          cc: PUBLIC_COLLECTION,
+          content: "Addressed to beta on the object",
+        }),
+      }),
+    );
+    assert.deepStrictEqual(events, ["message:beta"]);
+  });
+});
diff --git a/packages/botkit/src/instance.ts b/packages/botkit/src/instance.ts
new file mode 100644
index 0000000..0960062
--- /dev/null
+++ b/packages/botkit/src/instance.ts
@@ -0,0 +1,425 @@
+// BotKit by Fedify: A framework for creating ActivityPub bots
+// Copyright (C) 2025–2026 Hong Minhee <https://hongminhee.org/>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+import type {
+  Context,
+  Federation,
+  KvStore,
+  MessageQueue,
+} from "@fedify/fedify/federation";
+import type { Software } from "@fedify/fedify/nodeinfo";
+import type { Application, Image, Service } from "@fedify/vocab";
+import type { Bot, BotEventHandlers, PagesOptions } from "./bot.ts";
+import type { CustomEmoji, DeferredCustomEmoji } from "./emoji.ts";
+import { InstanceImpl } from "./instance-impl.ts";
+export { DEFAULT_INSTANCE_ACTOR_IDENTIFIER } from "./instance-impl.ts";
+import type { Repository } from "./repository.ts";
+import type { Session } from "./session.ts";
+import type { Text } from "./text.ts";
+
+/**
+ * The profile of a bot actor hosted on an {@link Instance}.  It configures
+ * everything about a bot except its identifier and the shared infrastructure,
+ * which belong to the instance.
+ * @since 0.5.0
+ */
+export interface BotProfile<TContextData> {
+  /**
+   * The type of the bot actor.  It should be either `Service` or
+   * `Application`.
+   *
+   * If omitted, `Service` will be used.
+   * @default `Service`
+   */
+  readonly class?: typeof Service | typeof Application;
+
+  /**
+   * The username of the bot.  It will be a part of the fediverse handle.
+   * It can be changed after the bot is federated.
+   */
+  readonly username: string;
+
+  /**
+   * The display name of the bot.  It can be changed after the bot is
+   * federated.
+   */
+  readonly name?: string;
+
+  /**
+   * The description of the bot.  It can be changed after the bot is
+   * federated.
+   */
+  readonly summary?: Text<"block", TContextData>;
+
+  /**
+   * The avatar URL of the bot.  It can be changed after the bot is federated.
+   */
+  readonly icon?: URL | Image;
+
+  /**
+   * The header image URL of the bot.  It can be changed after the bot is
+   * federated.
+   */
+  readonly image?: URL | Image;
+
+  /**
+   * The custom properties of the bot.  It can be changed after the bot is
+   * federated.
+   */
+  readonly properties?: Record<string, Text<"block" | "inline", TContextData>>;
+
+  /**
+   * How to handle incoming follow requests.  Note that this behavior can
+   * be overridden by manually invoking {@link FollowRequest.accept} or
+   * {@link FollowRequest.reject} in the {@link BotEventHandlers.onFollow}
+   * event handler.
+   *
+   * - `"accept"` (default): Automatically accept all incoming follow
+   *   requests.
+   * - `"reject"`: Automatically reject all incoming follow requests.
+   * - `"manual"`: Require manual handling of incoming follow requests.
+   * @default `"accept"`
+   */
+  readonly followerPolicy?: "accept" | "reject" | "manual";
+}
+
+/**
+ * A function that resolves the profile of a dynamically hosted bot from its
+ * identifier.  It is invoked whenever an identifier needs to be resolved,
+ * e.g. for dispatching an actor or routing an incoming activity, so it
+ * should be fast; look profiles up from a database rather than computing
+ * them expensively.
+ * @param ctx The Fedify context.
+ * @param identifier The identifier to resolve.
+ * @returns The profile of the bot, or `null` if the dispatcher does not
+ *          recognize the identifier.
+ * @since 0.5.0
+ */
+export type BotDispatcher<TContextData> = (
+  ctx: Context<TContextData>,
+  identifier: string,
+) => BotProfile<TContextData> | null | Promise<BotProfile<TContextData> | null>;
+
+/**
+ * Options for creating a dynamic {@link BotGroup}.
+ * @since 0.5.0
+ */
+export interface CreateBotGroupOptions<TContextData> {
+  /**
+   * Maps a WebFinger username to the identifier of a bot the group's
+   * dispatcher can resolve.  If omitted, usernames are assumed to equal
+   * identifiers.
+   * @param ctx The Fedify context.
+   * @param username The username to map.
+   * @returns The identifier of the bot, or `null` if the username does not
+   *          belong to this group.
+   */
+  mapUsername?(
+    ctx: Context<TContextData>,
+    username: string,
+  ): string | null | Promise<string | null>;
+}
+
+/**
+ * A group of dynamically hosted bots sharing the same event handlers.
+ * A group is created by passing a {@link BotDispatcher} to
+ * {@link Instance.createBot}; the dispatcher resolves individual bots
+ * on demand, and the handlers registered on the group are invoked for
+ * every bot it resolves.  Handlers can tell which bot they are running as
+ * through {@link Session.bot}.
+ * @since 0.5.0
+ */
+export interface BotGroup<TContextData> extends BotEventHandlers<TContextData> {
+  /**
+   * Gets a new session to control one of the group's bots for a specific
+   * origin and context data.
+   * @param origin The origin of the session.  Even if a URL with some path
+   *               or query is passed, only the origin part will be used.
+   * @param identifier The identifier of the bot to control.
+   * @param contextData The context data to pass to the federation.  It can
+   *                    be omitted when `TContextData` is `void`.
+   * @returns The session for the bot.
+   * @throws {TypeError} If the group's dispatcher does not resolve
+   *                     the identifier.
+   */
+  getSession(
+    origin: string | URL,
+    identifier: string,
+    contextData: TContextData,
+  ): Promise<Session<TContextData>>;
+}
+
+/**
+ * A server instance that can host multiple bots.  An instance owns the
+ * shared infrastructure—the key–value store, the message queue, the
+ * repository, and HTTP handling—while each bot hosted on it has its own
+ * actor identity and event handlers.
+ * @since 0.5.0
+ */
+export interface Instance<TContextData> {
+  /**
+   * An internal Fedify federation instance.  Normally you don't need to
+   * access this directly.
+   */
+  readonly federation: Federation<TContextData>;
+
+  /**
+   * Creates a bot with a fixed identifier and profile, hosted on this
+   * instance.
+   *
+   * @example
+   * ```typescript
+   * const greetBot = instance.createBot("greet", {
+   *   username: "greetbot",
+   *   name: "Greeting Bot",
+   * });
+   *
+   * greetBot.onFollow = async (session, followRequest) => {
+   *   await followRequest.accept();
+   * };
+   * ```
+   *
+   * @param identifier The internal identifier for the bot.  Since it is used
+   *                   for the actor URI, it *should not* be changed after
+   *                   the bot is federated.
+   * @param profile The profile of the bot.
+   * @returns The created bot.
+   * @throws {TypeError} If a bot with the same identifier or username
+   *                     already exists on the instance.
+   */
+  createBot(
+    identifier: string,
+    profile: BotProfile<TContextData>,
+  ): Bot<TContextData>;
+
+  /**
+   * Creates a group of dynamic bots resolved on demand by a dispatcher
+   * function.  This suits scenarios like “one bot per region,” where
+   * thousands of potential bots are backed by a database rather than
+   * declared up front.
+   *
+   * @example
+   * ```typescript
+   * const weatherBots = instance.createBot(async (ctx, identifier) => {
+   *   // Return null for identifiers this dispatcher doesn't handle:
+   *   if (!identifier.startsWith("weather_")) return null;
+   *   const region = await db.getRegion(identifier.slice("weather_".length));
+   *   if (region == null) return null;
+   *   return { username: identifier, name: `${region.name} Weather Bot` };
+   * });
+   *
+   * weatherBots.onMention = async (session, message) => {
+   *   // session.bot tells which bot is being mentioned:
+   *   const region = session.bot.identifier.slice("weather_".length);
+   *   await message.reply(text`The weather in ${region} is sunny!`);
+   * };
+   * ```
+   *
+   * @param dispatcher A function resolving a bot profile from an
+   *                   identifier, or `null` for identifiers it does not
+   *                   recognize.
+   * @param options The options for the group.
+   * @returns The created bot group.
+   */
+  createBot(
+    dispatcher: BotDispatcher<TContextData>,
+    options?: CreateBotGroupOptions<TContextData>,
+  ): BotGroup<TContextData>;
+
+  /**
+   * The fetch API for handling HTTP requests.  You can pass this to an HTTP
+   * server (e.g., `Deno.serve()`, `Bun.serve()`) to handle incoming
+   * requests.
+   * @param request The request to handle.
+   * @param contextData The context data to pass to the federation.
+   * @returns The response to the request.
+   */
+  fetch(request: Request, contextData: TContextData): Promise<Response>;
+
+  /**
+   * Defines custom emojis for the instance.  The custom emojis are shared by
+   * all bots hosted on the instance and are used for rendering their
+   * profiles and posts.
+   * @param emojis The custom emojis to define.  The keys are the names of
+   *               the emojis, and the values are the custom emoji
+   *               definitions.
+   * @returns The defined emojis.  The keys are the names of the emojis, and
+   *          the values are the emoji objects, which are used for passing
+   *          to the {@link customEmoji} function.
+   * @throws {TypeError} If any emoji name is invalid or duplicate.
+   */
+  addCustomEmojis<TEmojiName extends string>(
+    emojis: Readonly<Record<TEmojiName, CustomEmoji>>,
+  ): Readonly<Record<TEmojiName, DeferredCustomEmoji<TContextData>>>;
+}
+
+/**
+ * A specialized {@link Instance} type that doesn't require context data.
+ * @since 0.5.0
+ */
+export interface InstanceWithVoidContextData extends Instance<void> {
+  /**
+   * The fetch API for handling HTTP requests.  You can pass this to an HTTP
+   * server (e.g., `Deno.serve()`, `Bun.serve()`) to handle incoming
+   * requests.
+   * @param request The request to handle.
+   * @returns The response to the request.
+   */
+  fetch(request: Request): Promise<Response>;
+}
+
+/**
+ * Options for creating an {@link Instance}.
+ * @since 0.5.0
+ */
+export interface CreateInstanceOptions {
+  /**
+   * The underlying key–value store to use for storing data.
+   */
+  readonly kv: KvStore;
+
+  /**
+   * The repository to use for storing bot data.  A single repository stores
+   * the data of every bot hosted on the instance, scoped by their
+   * identifiers.  If omitted, a {@link KvRepository} backed by `kv` will be
+   * used.
+   */
+  readonly repository?: Repository;
+
+  /**
+   * The underlying message queue to use for handling incoming and outgoing
+   * activities.  If omitted, incoming activities are processed immediately,
+   * and outgoing activities are sent immediately.
+   */
+  readonly queue?: MessageQueue;
+
+  /**
+   * The software information of the instance.  If omitted, the NodeInfo
+   * protocol will be unimplemented.
+   */
+  readonly software?: Software;
+
+  /**
+   * Whether to trust `X-Forwarded-*` headers.  If your instance is behind
+   * an L7 reverse proxy, turn it on.
+   *
+   * Turned off by default.
+   * @default `false`
+   */
+  readonly behindProxy?: boolean;
+
+  /**
+   * The options for the web pages of the instance.  If omitted, the default
+   * options will be used.
+   */
+  readonly pages?: PagesOptions;
+
+  /**
+   * The identifier of the instance actor: an internal `Application` actor
+   * the instance uses for signing shared-inbox related requests.  Override
+   * it when the default identifier collides with a bot you want to host.
+   * Since it is used for the actor URI, it *should not* be changed after
+   * the instance is federated.
+   * @default `"__botkit_instance__"`
+   */
+  readonly instanceActorIdentifier?: string;
+
+  /**
+   * Configures the recognition of local object URIs in the legacy (pre-0.5)
+   * format, which did not carry the owning bot actor identifier.  Set this
+   * when the instance hosts a bot that was deployed with BotKit 0.4 or
+   * earlier, so that object URIs stored by remote servers keep working.
+   *
+   * Legacy URIs can only occur in deployments that hosted a single bot
+   * before the upgrade, so they are attributed to the configured bot.
+   */
+  readonly legacyObjectUris?: {
+    /**
+     * The identifier of the bot actor that owns objects with legacy URIs.
+     */
+    readonly identifier: string;
+  };
+}
+
+/**
+ * Creates an {@link Instance} that can host multiple bots sharing the same
+ * infrastructure.
+ *
+ * @example
+ * ```typescript
+ * import { createInstance } from "@fedify/botkit";
+ * import { MemoryKvStore } from "@fedify/fedify/federation";
+ *
+ * const instance = createInstance<void>({ kv: new MemoryKvStore() });
+ * const greetBot = instance.createBot("greet", { username: "greetbot" });
+ *
+ * export default instance;
+ * ```
+ *
+ * @param options The options for creating the instance.
+ * @returns The created instance.
+ * @since 0.5.0
+ */
+export function createInstance<TContextData = void>(
+  options: CreateInstanceOptions,
+): TContextData extends void ? InstanceWithVoidContextData
+  : Instance<TContextData> {
+  const instance = new InstanceImpl<TContextData>(options);
+  function createBotFn(
+    identifier: string,
+    profile: BotProfile<TContextData>,
+  ): Bot<TContextData>;
+  function createBotFn(
+    dispatcher: BotDispatcher<TContextData>,
+    options?: CreateBotGroupOptions<TContextData>,
+  ): BotGroup<TContextData>;
+  function createBotFn(
+    identifierOrDispatcher: string | BotDispatcher<TContextData>,
+    profileOrOptions?:
+      | BotProfile<TContextData>
+      | CreateBotGroupOptions<TContextData>,
+  ): Bot<TContextData> | BotGroup<TContextData> {
+    if (typeof identifierOrDispatcher === "string") {
+      return instance.createBot(
+        identifierOrDispatcher,
+        profileOrOptions as BotProfile<TContextData>,
+      );
+    }
+    return instance.createBot(
+      identifierOrDispatcher,
+      profileOrOptions as CreateBotGroupOptions<TContextData> | undefined,
+    );
+  }
+  // Since `deno serve` does not recognize a class instance having fetch(),
+  // we wrap an InstanceImpl instance with a plain object.
+  // See also https://github.com/denoland/deno/issues/24062
+  const wrapper = {
+    impl: instance,
+    get federation(): Federation<TContextData> {
+      return instance.federation;
+    },
+    createBot: createBotFn,
+    fetch(request: Request, contextData: TContextData): Promise<Response> {
+      return instance.fetch(request, contextData);
+    },
+    addCustomEmojis<TEmojiName extends string>(
+      emojis: Readonly<Record<TEmojiName, CustomEmoji>>,
+    ): Readonly<Record<TEmojiName, DeferredCustomEmoji<TContextData>>> {
+      return instance.addCustomEmojis(emojis);
+    },
+  } satisfies Instance<TContextData> & { impl: InstanceImpl<TContextData> };
+  // @ts-ignore: the wrapper implements InstanceWithVoidContextData
+  return wrapper;
+}
diff --git a/packages/botkit/src/message-impl.test.ts b/packages/botkit/src/message-impl.test.ts
index 09fe43c..ce37ae7 100644
--- a/packages/botkit/src/message-impl.test.ts
+++ b/packages/botkit/src/message-impl.test.ts
@@ -45,6 +45,7 @@ import {
   isMessageObject,
 } from "./message-impl.ts";
 import { MemoryRepository } from "./repository.ts";
+import { InstanceImpl } from "./instance-impl.ts";
 import { createMockContext } from "./session-impl.test.ts";
 import { SessionImpl } from "./session-impl.ts";
 import { text } from "./text.ts";
@@ -213,6 +214,7 @@ test("AuthorizedMessageImpl.delete()", async () => {
     true,
   );
   await repository.addMessage(
+    "bot",
     "c1c792ce-a0be-4685-b396-e59e5ef8c788",
     new Create({
       id: new URL(
@@ -225,7 +227,7 @@ test("AuthorizedMessageImpl.delete()", async () => {
     }),
   );
   await msg.delete();
-  assert.deepStrictEqual(await repository.countMessages(), 0);
+  assert.deepStrictEqual(await repository.countMessages("bot"), 0);
   assert.deepStrictEqual(ctx.sentActivities.length, 1);
   const { recipients, activity } = ctx.sentActivities[0];
   assert.deepStrictEqual(recipients, "followers");
@@ -265,8 +267,8 @@ test("MessageImpl.reply()", async () => {
     {},
   );
   const reply = await originalMsg.reply(text`Hello, John!`);
-  assert.deepStrictEqual(await repository.countMessages(), 1);
-  const [create] = await Array.fromAsync(repository.getMessages());
+  assert.deepStrictEqual(await repository.countMessages("bot"), 1);
+  const [create] = await Array.fromAsync(repository.getMessages("bot"));
   assert.ok(create != null);
   assert.deepStrictEqual(ctx.sentActivities.length, 2);
   const { recipients, activity } = ctx.sentActivities[0];
@@ -322,8 +324,8 @@ test("MessageImpl.share()", async (t) => {
   const sharedMsg = await originalMsg.share();
 
   await t.test("share()", async () => {
-    assert.deepStrictEqual(await repository.countMessages(), 1);
-    const [announce] = await Array.fromAsync(repository.getMessages());
+    assert.deepStrictEqual(await repository.countMessages("bot"), 1);
+    const [announce] = await Array.fromAsync(repository.getMessages("bot"));
     assert.ok(announce != null);
     assert.deepStrictEqual(ctx.sentActivities.length, 2);
     const { recipients, activity } = ctx.sentActivities[0];
@@ -368,7 +370,7 @@ test("MessageImpl.share()", async (t) => {
     ctx.sentActivities = [];
 
     await sharedMsg.unshare();
-    assert.deepStrictEqual(await repository.countMessages(), 0);
+    assert.deepStrictEqual(await repository.countMessages("bot"), 0);
     assert.deepStrictEqual(ctx.sentActivities.length, 2);
     const { recipients, activity } = ctx.sentActivities[0];
     assert.deepStrictEqual(recipients, "followers");
@@ -487,7 +489,7 @@ test("AuthorizedMessage.update()", async (t) => {
 
     await t.test(visibility, async () => {
       const msg = await session.publish(text`Hello, ${actorA}`, { visibility });
-      assert.deepStrictEqual(await repository.countMessages(), 1);
+      assert.deepStrictEqual(await repository.countMessages("bot"), 1);
       const originalRaw = msg.raw;
       ctx.sentActivities = [];
       const before = Temporal.Now.instant();
@@ -535,7 +537,7 @@ test("AuthorizedMessage.update()", async (t) => {
       assert.deepStrictEqual(tags[0].href, actorB.id);
       assert.deepStrictEqual(msg.raw.published, originalRaw.published);
       assert.deepStrictEqual(msg.raw.updated, msg.updated);
-      const [create] = await Array.fromAsync(repository.getMessages());
+      const [create] = await Array.fromAsync(repository.getMessages("bot"));
       assert.deepStrictEqual(
         await (await create.getObject())?.toJsonLd({ format: "compact" }),
         await msg.raw.toJsonLd({ format: "compact" }),
@@ -777,3 +779,55 @@ test("MessageImpl.react()", async (t) => {
     assert.deepStrictEqual(urTags[0], tags[0]); // Should be the resolved CustomEmoji
   });
 });
+
+test("AuthorizedMessage ignores other bots' messages", async (t) => {
+  const repository = new MemoryRepository();
+  const instance = new InstanceImpl<void>({
+    kv: new MemoryKvStore(),
+    repository,
+  });
+  instance.createBot("alpha", { username: "alphabot" });
+  instance.createBot("beta", { username: "betabot" });
+  const alpha = instance.getBot("alpha")!;
+  const beta = instance.getBot("beta")!;
+
+  // alpha publishes a message:
+  const alphaCtx = createMockContext(alpha, "https://example.com");
+  const alphaSession = new SessionImpl(alpha, alphaCtx);
+  const published = await alphaSession.publish(text`Hello from alpha!`);
+  assert.deepStrictEqual(await repository.countMessages("alpha"), 1);
+
+  // An authorized view of alpha's message under beta's session must not be
+  // able to touch alpha's data, since the URI identifies alpha as the owner:
+  const betaCtx = createMockContext(beta, "https://example.com");
+  const betaSession = new SessionImpl(beta, betaCtx);
+  // The attribution is embedded so that no remote fetch is needed;
+  // the message URI still identifies alpha as the owner:
+  const rawWithActor = published.raw.clone({
+    attribution: await alphaSession.getActor(),
+  });
+  const crossBot = await createMessage(
+    rawWithActor,
+    betaSession,
+    {},
+    undefined,
+    undefined,
+    true,
+  );
+
+  await t.test("update() is a no-op", async () => {
+    betaCtx.sentActivities = [];
+    await crossBot.update(text`Hijacked!`);
+    assert.deepStrictEqual(betaCtx.sentActivities, []);
+    const [stored] = await Array.fromAsync(repository.getMessages("alpha"));
+    const object = await stored.getObject(alphaCtx);
+    assert.ok(object?.content?.toString().includes("Hello from alpha!"));
+  });
+
+  await t.test("delete() is a no-op", async () => {
+    betaCtx.sentActivities = [];
+    await crossBot.delete();
+    assert.deepStrictEqual(betaCtx.sentActivities, []);
+    assert.deepStrictEqual(await repository.countMessages("alpha"), 1);
+  });
+});
diff --git a/packages/botkit/src/message-impl.ts b/packages/botkit/src/message-impl.ts
index 3eb45cc..5afb4a0 100644
--- a/packages/botkit/src/message-impl.ts
+++ b/packages/botkit/src/message-impl.ts
@@ -39,6 +39,7 @@ import {
 } from "@fedify/vocab";
 import { decode } from "html-entities";
 import { v7 as uuidv7 } from "uuid";
+import { parseLocalUri } from "./uri.ts";
 import xss from "xss";
 import type { DeferredCustomEmoji, Emoji } from "./emoji.ts";
 import type {
@@ -148,7 +149,10 @@ export class MessageImpl<T extends MessageClass, TContextData>
     const id = uuidv7({ msecs: +published }) as Uuid;
     const visibility = options.visibility ?? this.visibility;
     const originalActor = this.actor.id == null ? [] : [this.actor.id];
-    const uri = this.session.context.getObjectUri(Announce, { id });
+    const uri = this.session.context.getObjectUri(Announce, {
+      identifier: this.session.bot.identifier,
+      id,
+    });
     const announce = new Announce({
       id: uri,
       actor: this.session.context.getActorUri(this.session.bot.identifier),
@@ -373,10 +377,15 @@ export class AuthorizedMessageImpl<T extends MessageClass, TContextData>
   extends MessageImpl<T, TContextData>
   implements AuthorizedMessage<T, TContextData> {
   async update(text: Text<"block", TContextData>): Promise<void> {
-    const parsed = this.session.context.parseUri(this.id);
+    const parsed = parseLocalUri(
+      this.session.context,
+      this.id,
+      this.session.bot.legacyObjectUrisIdentifier,
+    );
     if (
       parsed?.type !== "object" ||
-      !messageClasses.some((cls) => parsed.class === cls)
+      !messageClasses.some((cls) => parsed.class === cls) ||
+      parsed.values.identifier !== this.session.bot.identifier
     ) {
       return;
     }
@@ -464,7 +473,10 @@ export class AuthorizedMessageImpl<T extends MessageClass, TContextData>
         update = new Update({
           id: new URL(
             `#updated/${updated.toString()}`,
-            this.session.context.getObjectUri(Create, { id }),
+            this.session.context.getObjectUri(Create, {
+              identifier: this.session.bot.identifier,
+              id,
+            }),
           ),
           actors: newMessage.attributionIds,
           tos: to.map((url) => new URL(url)),
@@ -512,10 +524,15 @@ export class AuthorizedMessageImpl<T extends MessageClass, TContextData>
   }
 
   async delete(): Promise<void> {
-    const parsed = this.session.context.parseUri(this.id);
+    const parsed = parseLocalUri(
+      this.session.context,
+      this.id,
+      this.session.bot.legacyObjectUrisIdentifier,
+    );
     if (
       parsed?.type !== "object" ||
-      !messageClasses.some((cls) => parsed.class === cls)
+      !messageClasses.some((cls) => parsed.class === cls) ||
+      parsed.values.identifier !== this.session.bot.identifier
     ) {
       return;
     }
@@ -664,9 +681,16 @@ export async function createMessage<T extends MessageClass, TContextData>(
   }
   if (replyTarget == null) {
     let rt: Link | Object | null;
-    const parsed = session.context.parseUri(raw.replyTargetId);
-    // @ts-ignore: The `class` property satisfies the `MessageClass` type.
-    if (parsed?.type === "object" && messageClasses.includes(parsed.class)) {
+    const parsed = parseLocalUri(
+      session.context,
+      raw.replyTargetId,
+      session.bot.legacyObjectUrisIdentifier,
+    );
+    if (
+      // @ts-ignore: The `class` property satisfies the `MessageClass` type.
+      parsed?.type === "object" && messageClasses.includes(parsed.class) &&
+      parsed.values.identifier === session.bot.identifier
+    ) {
       // @ts-ignore: The `class` property satisfies the `MessageClass` type.
       // deno-lint-ignore no-explicit-any
       const cls: new (values: any) => T = parsed.class;
@@ -694,9 +718,16 @@ export async function createMessage<T extends MessageClass, TContextData>(
     }
     if (quoteUrl == null) quoteUrl = raw.quoteUrl;
     let qt: Object | null = null;
-    const parsed = session.context.parseUri(quoteUrl);
-    // @ts-ignore: The `class` property satisfies the `MessageClass` type.
-    if (parsed?.type === "object" && messageClasses.includes(parsed.class)) {
+    const parsed = parseLocalUri(
+      session.context,
+      quoteUrl,
+      session.bot.legacyObjectUrisIdentifier,
+    );
+    if (
+      // @ts-ignore: The `class` property satisfies the `MessageClass` type.
+      parsed?.type === "object" && messageClasses.includes(parsed.class) &&
+      parsed.values.identifier === session.bot.identifier
+    ) {
       // @ts-ignore: The `class` property satisfies the `MessageClass` type.
       // deno-lint-ignore no-explicit-any
       const cls: new (values: any) => T = parsed.class;
diff --git a/packages/botkit/src/mod.ts b/packages/botkit/src/mod.ts
index 7594fbf..dcfb414 100644
--- a/packages/botkit/src/mod.ts
+++ b/packages/botkit/src/mod.ts
@@ -22,14 +22,27 @@ export {
 export {
   Application,
   type Bot,
+  type BotEventHandlers,
   type BotWithVoidContextData,
   createBot,
   type CreateBotOptions,
   Image,
   type PagesOptions,
+  type ReadonlyBot,
   Service,
   type Software,
 } from "./bot.ts";
+export {
+  type BotDispatcher,
+  type BotGroup,
+  type BotProfile,
+  type CreateBotGroupOptions,
+  createInstance,
+  type CreateInstanceOptions,
+  DEFAULT_INSTANCE_ACTOR_IDENTIFIER,
+  type Instance,
+  type InstanceWithVoidContextData,
+} from "./instance.ts";
 export {
   type CustomEmoji,
   type DeferredCustomEmoji,
@@ -70,9 +83,11 @@ export {
   type Reaction,
 } from "./reaction.ts";
 export {
+  ActorScopedRepository,
   Announce,
   Create,
   KvRepository,
+  type KvRepositoryOptions,
   MemoryCachedRepository,
   MemoryRepository,
   type Repository,
diff --git a/packages/botkit/src/pages.test.ts b/packages/botkit/src/pages.test.ts
new file mode 100644
index 0000000..37dfd23
--- /dev/null
+++ b/packages/botkit/src/pages.test.ts
@@ -0,0 +1,260 @@
+// BotKit by Fedify: A framework for creating ActivityPub bots
+// Copyright (C) 2025–2026 Hong Minhee <https://hongminhee.org/>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+import { MemoryKvStore } from "@fedify/fedify/federation";
+import { Create, Note, PUBLIC_COLLECTION } from "@fedify/vocab";
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { BotImpl } from "./bot-impl.ts";
+import { InstanceImpl } from "./instance-impl.ts";
+import { MemoryRepository, type Uuid } from "./repository.ts";
+
+const messageId: Uuid = "01941f29-7c00-7fe8-ab0a-7b593990a3c0";
+
+async function seedMessage(
+  repository: MemoryRepository,
+  identifier: string,
+): Promise<void> {
+  await repository.addMessage(
+    identifier,
+    messageId,
+    new Create({
+      id: new URL(
+        `https://example.com/ap/actor/${identifier}/create/${messageId}`,
+      ),
+      actor: new URL(`https://example.com/ap/actor/${identifier}`),
+      to: PUBLIC_COLLECTION,
+      object: new Note({
+        id: new URL(
+          `https://example.com/ap/actor/${identifier}/note/${messageId}`,
+        ),
+        attribution: new URL(`https://example.com/ap/actor/${identifier}`),
+        to: PUBLIC_COLLECTION,
+        content: "Hello, world!",
+        published: Temporal.Instant.from("2025-01-01T00:00:00Z"),
+      }),
+      published: Temporal.Instant.from("2025-01-01T00:00:00Z"),
+    }),
+  );
+}
+
+describe("single-bot web pages", () => {
+  test("serve the bot at the web root", async () => {
+    const repository = new MemoryRepository();
+    const bot = new BotImpl<void>({
+      kv: new MemoryKvStore(),
+      repository,
+      username: "mybot",
+      name: "My Bot",
+    });
+    await seedMessage(repository, "bot");
+    const profile = await bot.fetch(
+      new Request("https://example.com/"),
+      undefined,
+    );
+    assert.deepStrictEqual(profile.status, 200);
+    const html = await profile.text();
+    assert.ok(html.includes("@mybot@example.com"));
+    assert.ok(html.includes('action="/follow"'));
+
+    const message = await bot.fetch(
+      new Request(`https://example.com/message/${messageId}`),
+      undefined,
+    );
+    assert.deepStrictEqual(message.status, 200);
+
+    const feed = await bot.fetch(
+      new Request("https://example.com/feed.xml"),
+      undefined,
+    );
+    assert.deepStrictEqual(feed.status, 200);
+    assert.ok(
+      feed.headers.get("Content-Type")?.startsWith("application/atom+xml"),
+    );
+  });
+
+  test("use root-relative web URLs", () => {
+    const bot = new BotImpl<void>({
+      kv: new MemoryKvStore(),
+      username: "mybot",
+    });
+    assert.deepStrictEqual(
+      bot.instance.getBotWebUrl(bot, "https://example.com").href,
+      "https://example.com/",
+    );
+    assert.deepStrictEqual(
+      bot.instance.getMessageWebUrl(bot, messageId, "https://example.com")
+        .href,
+      `https://example.com/message/${messageId}`,
+    );
+  });
+});
+
+describe("multi-bot web pages", () => {
+  function createInstanceWithBots(): {
+    instance: InstanceImpl<void>;
+    repository: MemoryRepository;
+  } {
+    const repository = new MemoryRepository();
+    const instance = new InstanceImpl<void>({
+      kv: new MemoryKvStore(),
+      repository,
+    });
+    instance.createBot("alpha", { username: "alphabot", name: "Alpha" });
+    instance.createBot("beta", { username: "betabot", name: "Beta" });
+    return { instance, repository };
+  }
+
+  test("list the hosted bots at the web root", async () => {
+    const { instance } = createInstanceWithBots();
+    const response = await instance.fetch(
+      new Request("https://example.com/"),
+      undefined,
+    );
+    assert.deepStrictEqual(response.status, 200);
+    const html = await response.text();
+    assert.ok(html.includes("@alphabot@example.com"));
+    assert.ok(html.includes("@betabot@example.com"));
+    assert.ok(html.includes('href="/@alphabot"'));
+  });
+
+  test("serve per-bot profiles under /@{username}", async () => {
+    const { instance } = createInstanceWithBots();
+    const response = await instance.fetch(
+      new Request("https://example.com/@alphabot"),
+      undefined,
+    );
+    assert.deepStrictEqual(response.status, 200);
+    const html = await response.text();
+    assert.ok(html.includes("@alphabot@example.com"));
+    assert.ok(html.includes('action="/@alphabot/follow"'));
+    assert.ok(!html.includes("@betabot@example.com"));
+
+    const unknown = await instance.fetch(
+      new Request("https://example.com/@nobody"),
+      undefined,
+    );
+    assert.deepStrictEqual(unknown.status, 404);
+  });
+
+  test("serve per-bot message permalinks and feeds", async () => {
+    const { instance, repository } = createInstanceWithBots();
+    await seedMessage(repository, "alpha");
+
+    const message = await instance.fetch(
+      new Request(`https://example.com/@alphabot/${messageId}`),
+      undefined,
+    );
+    assert.deepStrictEqual(message.status, 200);
+
+    // Another bot's path must not serve the message:
+    const cross = await instance.fetch(
+      new Request(`https://example.com/@betabot/${messageId}`),
+      undefined,
+    );
+    assert.deepStrictEqual(cross.status, 404);
+
+    const feed = await instance.fetch(
+      new Request("https://example.com/@alphabot/feed.xml"),
+      undefined,
+    );
+    assert.deepStrictEqual(feed.status, 200);
+    assert.ok(
+      feed.headers.get("Content-Type")?.startsWith("application/atom+xml"),
+    );
+    const followers = await instance.fetch(
+      new Request("https://example.com/@alphabot/followers"),
+      undefined,
+    );
+    assert.deepStrictEqual(followers.status, 200);
+  });
+
+  test("use username-based web URLs", () => {
+    const { instance } = createInstanceWithBots();
+    const alpha = instance.getBot("alpha")!;
+    assert.deepStrictEqual(
+      instance.getBotWebUrl(alpha, "https://example.com").href,
+      "https://example.com/@alphabot",
+    );
+    assert.deepStrictEqual(
+      instance.getMessageWebUrl(alpha, messageId, "https://example.com").href,
+      `https://example.com/@alphabot/${messageId}`,
+    );
+  });
+
+  test("advertise the web URL on the actor", async () => {
+    const { instance } = createInstanceWithBots();
+    const response = await instance.fetch(
+      new Request("https://example.com/ap/actor/alpha", {
+        headers: { Accept: "application/activity+json" },
+      }),
+      undefined,
+    );
+    assert.deepStrictEqual(response.status, 200);
+    const actor = await response.json();
+    assert.deepStrictEqual(actor.url, "https://example.com/@alphabot");
+  });
+});
+
+describe("usernames requiring percent-encoding", () => {
+  test("keep web paths and routes consistent", async () => {
+    const instance = new InstanceImpl<void>({
+      kv: new MemoryKvStore(),
+      repository: new MemoryRepository(),
+    });
+    instance.createBot("alpha", { username: "weird+bot" });
+    instance.createBot("beta", { username: "betabot" });
+    const alpha = instance.getBot("alpha")!;
+    const url = instance.getBotWebUrl(alpha, "https://example.com");
+    assert.deepStrictEqual(url.href, "https://example.com/@weird%2Bbot");
+    const response = await instance.fetch(new Request(url), undefined);
+    assert.deepStrictEqual(response.status, 200);
+    const html = await response.text();
+    assert.ok(html.includes("weird+bot"));
+  });
+});
+
+describe("custom CSS", () => {
+  const css = "main > p { color: red; }";
+
+  test("is not HTML-escaped on single-bot pages", async () => {
+    const bot = new BotImpl<void>({
+      kv: new MemoryKvStore(),
+      username: "mybot",
+      pages: { css },
+    });
+    const response = await bot.fetch(
+      new Request("https://example.com/"),
+      undefined,
+    );
+    const html = await response.text();
+    assert.ok(html.includes(css));
+  });
+
+  test("is not HTML-escaped on the instance index", async () => {
+    const instance = new InstanceImpl<void>({
+      kv: new MemoryKvStore(),
+      repository: new MemoryRepository(),
+      pages: { css },
+    });
+    instance.createBot("alpha", { username: "alphabot" });
+    const response = await instance.fetch(
+      new Request("https://example.com/"),
+      undefined,
+    );
+    const html = await response.text();
+    assert.ok(html.includes(css));
+  });
+});
diff --git a/packages/botkit/src/pages.tsx b/packages/botkit/src/pages.tsx
index 1031db4..b1e9a31 100644
--- a/packages/botkit/src/pages.tsx
+++ b/packages/botkit/src/pages.tsx
@@ -29,11 +29,13 @@ import {
 import { Hono } from "hono";
 import { decode } from "html-entities";
 import { parseTemplate } from "url-template";
+import type { Context as HonoContext } from "hono";
 import type { BotImpl } from "./bot-impl.ts";
 import { FollowButton } from "./components/FollowButton.tsx";
 import { Follower } from "./components/Follower.tsx";
 import { Layout } from "./components/Layout.tsx";
 import { Message } from "./components/Message.tsx";
+import type { InstanceImpl } from "./instance-impl.ts";
 import { getMessageClass, isMessageObject, textXss } from "./message-impl.ts";
 import type { MessageClass } from "./message.ts";
 import type { Uuid } from "./repository.ts";
@@ -47,11 +49,30 @@ export interface Env {
   readonly Bindings: Bindings;
 }
 
+export interface InstanceBindings {
+  readonly instance: InstanceImpl<unknown>;
+  readonly contextData: unknown;
+}
+
+export interface InstanceEnv {
+  readonly Bindings: InstanceBindings;
+}
+
+// deno-lint-ignore no-explicit-any
+type PageContext = HonoContext<any>;
+
 export const app = new Hono<Env>();
 
-app.get("/", async (c) => {
-  const { bot } = c.env;
-  const ctx = bot.federation.createContext(c.req.raw, c.env.contextData);
+app.get("/", (c) => profilePage(c, c.env.bot, c.env.contextData, ""));
+
+async function profilePage(
+  c: PageContext,
+  bot: BotImpl<unknown>,
+  contextData: unknown,
+  base: string,
+): Promise<Response> {
+  const home = base === "" ? "/" : base;
+  const ctx = bot.federation.createContext(c.req.raw, contextData);
   const session = bot.getSession(ctx);
   const url = new URL(c.req.url);
   const handle = `@${bot.username}@${url.host}`;
@@ -84,10 +105,10 @@ app.get("/", async (c) => {
     offset ? { offset: Temporal.Instant.from(offset) } : {},
   );
   const activityLink = ctx.getActorUri(bot.identifier);
-  const feedLink = new URL("/feed.xml", url);
+  const feedLink = new URL(`${base}/feed.xml`, url);
   let nextLink: URL | undefined;
   if (nextPost?.published != null) {
-    nextLink = new URL("/", url);
+    nextLink = new URL(home, url);
     nextLink.searchParams.set("offset", nextPost.published.toString());
   }
   return c.html(
@@ -119,12 +140,12 @@ app.get("/", async (c) => {
             />
           )}
           <h1>
-            <a href="/">{bot.name ?? bot.username}</a>
+            <a href={home}>{bot.name ?? bot.username}</a>
           </h1>
           <p>
             <span style="user-select: all;">{handle}</span> &middot;{" "}
             <a
-              href="/feed.xml"
+              href={`${base}/feed.xml`}
               rel="alternate"
               type="application/atom+xml"
               title="Atom feed"
@@ -145,7 +166,7 @@ app.get("/", async (c) => {
             </a>{" "}
             &middot;{" "}
             <span>
-              <a href="/followers">
+              <a href={`${base}/followers`}>
                 {followersCount === 1
                   ? `1 follower`
                   : `${followersCount.toLocaleString("en")} followers`}
@@ -157,7 +178,7 @@ app.get("/", async (c) => {
                 ? `1 post`
                 : `${postsCount.toLocaleString("en")} posts`}
             </span>{" "}
-            &middot; <FollowButton bot={bot} />
+            &middot; <FollowButton bot={bot} action={`${base}/follow`} />
           </p>
         </hgroup>
         {summary &&
@@ -209,18 +230,28 @@ app.get("/", async (c) => {
       },
     },
   );
-});
+}
+
+app.get(
+  "/followers",
+  (c) => followersPage(c, c.env.bot, c.env.contextData, ""),
+);
 
-app.get("/followers", async (c) => {
-  const { bot } = c.env;
-  const ctx = bot.federation.createContext(c.req.raw, c.env.contextData);
+async function followersPage(
+  c: PageContext,
+  bot: BotImpl<unknown>,
+  contextData: unknown,
+  base: string,
+): Promise<Response> {
+  const home = base === "" ? "/" : base;
+  const ctx = bot.federation.createContext(c.req.raw, contextData);
   const session = bot.getSession(ctx);
   const followersCount = await bot.repository.countFollowers();
   const followers = await Array.fromAsync(bot.repository.getFollowers());
 
   const url = new URL(c.req.url);
   const activityLink = ctx.getActorUri(bot.identifier);
-  const feedLink = new URL("/feed.xml", url);
+  const feedLink = new URL(`${base}/feed.xml`, url);
 
   return c.html(
     <Layout
@@ -231,7 +262,7 @@ app.get("/followers", async (c) => {
     >
       <header class="container">
         <h1>
-          <a href="/">&larr;</a>{" "}
+          <a href={home}>&larr;</a>{" "}
           {followersCount === 1
             ? `1 follower`
             : `${followersCount.toLocaleString("en")} followers`}
@@ -248,13 +279,23 @@ app.get("/followers", async (c) => {
       </main>
     </Layout>,
   );
-});
+}
+
+app.get(
+  "/tags/:hashtag",
+  (c) => hashtagPage(c, c.env.bot, c.env.contextData, ""),
+);
 
-app.get("/tags/:hashtag", async (c) => {
+async function hashtagPage(
+  c: PageContext,
+  bot: BotImpl<unknown>,
+  contextData: unknown,
+  base: string,
+): Promise<Response> {
   const hashtag = c.req.param("hashtag");
-  const { bot } = c.env;
+  if (hashtag == null) return c.notFound();
   const url = new URL(c.req.url);
-  const ctx = bot.federation.createContext(c.req.raw, c.env.contextData);
+  const ctx = bot.federation.createContext(c.req.raw, contextData);
   const session = bot.getSession(ctx);
   const offset = c.req.query("offset");
   const { posts, nextPost } = await getPosts(bot, ctx, {
@@ -263,7 +304,7 @@ app.get("/tags/:hashtag", async (c) => {
   });
   let nextLink: URL | undefined;
   if (nextPost?.published != null) {
-    nextLink = new URL(`/tags/${encodeURIComponent(hashtag)}`, url);
+    nextLink = new URL(`${base}/tags/${encodeURIComponent(hashtag)}`, url);
     nextLink.searchParams.set("offset", nextPost.published.toString());
   }
   return c.html(
@@ -273,13 +314,18 @@ app.get("/tags/:hashtag", async (c) => {
       </header>
       <main class="container">
         {posts.map((message) => (
-          <Message message={message} session={session} />
+          <Message
+            message={message}
+            session={session}
+          />
         ))}
       </main>
       <footer class="container">
         <nav style="display: block; text-align: end;">
           {nextLink && (
-            <a rel="next" href={nextLink.href}>Older posts &rarr;</a>
+            <a rel="next" href={nextLink.href}>
+              Older posts &rarr;
+            </a>
           )}
         </nav>
       </footer>
@@ -290,13 +336,23 @@ app.get("/tags/:hashtag", async (c) => {
       },
     },
   );
-});
+}
 
-app.get("/message/:id", async (c) => {
+app.get(
+  "/message/:id",
+  (c) => messagePage(c, c.env.bot, c.env.contextData, ""),
+);
+
+async function messagePage(
+  c: PageContext,
+  bot: BotImpl<unknown>,
+  contextData: unknown,
+  base: string,
+): Promise<Response> {
   const id = c.req.param("id");
-  const { bot } = c.env;
+  if (id == null) return c.notFound();
   const url = new URL(c.req.url);
-  const ctx = bot.federation.createContext(c.req.raw, c.env.contextData);
+  const ctx = bot.federation.createContext(c.req.raw, contextData);
   const session = bot.getSession(ctx);
   const post = await bot.repository.getMessage(id as Uuid);
   if (post == null || !isPublic(post)) return c.notFound();
@@ -304,9 +360,9 @@ app.get("/message/:id", async (c) => {
   if (message == null || !isMessageObject(message)) return c.notFound();
   const activityLink = ctx.getObjectUri<MessageClass>(
     getMessageClass(message),
-    { id },
+    { identifier: bot.identifier, id },
   );
-  const feedLink = new URL("/feed.xml", url);
+  const feedLink = new URL(`${base}/feed.xml`, url);
   let title = message.name;
   if (title == null) {
     title = message.summary ?? message.content;
@@ -334,17 +390,24 @@ app.get("/message/:id", async (c) => {
       },
     },
   );
-});
+}
+
+app.get("/feed.xml", (c) => feedPage(c, c.env.bot, c.env.contextData, ""));
 
-app.get("/feed.xml", async (c) => {
-  const { bot } = c.env;
+async function feedPage(
+  c: PageContext,
+  bot: BotImpl<unknown>,
+  contextData: unknown,
+  base: string,
+): Promise<Response> {
+  const home = base === "" ? "/" : base;
   const url = new URL(c.req.url);
-  const ctx = bot.federation.createContext(c.req.raw, c.env.contextData);
+  const ctx = bot.federation.createContext(c.req.raw, contextData);
   const session = bot.getSession(ctx);
   const { posts } = await getPosts(bot, ctx, { window: 30 });
   const botName = bot.name ?? bot.username;
-  const canonicalUrl = new URL("/feed.xml", url);
-  const profileUrl = new URL("/", url);
+  const canonicalUrl = new URL(`${base}/feed.xml`, url);
+  const profileUrl = new URL(home, url);
   const actorUrl = ctx.getActorUri(bot.identifier);
   c.header(
     "Link",
@@ -431,11 +494,18 @@ app.get("/feed.xml", async (c) => {
   );
   response.headers.set("Content-Type", "application/atom+xml; charset=utf-8");
   return response;
-});
+}
+
+app.post("/follow", (c) => followPage(c, c.env.bot, c.env.contextData, ""));
 
-app.post("/follow", async (c) => {
-  const { bot } = c.env;
-  const ctx = bot.federation.createContext(c.req.raw, c.env.contextData);
+async function followPage(
+  c: PageContext,
+  bot: BotImpl<unknown>,
+  contextData: unknown,
+  base: string,
+): Promise<Response> {
+  const home = base === "" ? "/" : base;
+  const ctx = bot.federation.createContext(c.req.raw, contextData);
   const url = new URL(c.req.url);
 
   const formData = await c.req.formData();
@@ -449,7 +519,7 @@ app.post("/follow", async (c) => {
             <h1>Error</h1>
             <p>Follower handle is required.</p>
             <p>
-              <a href="/">Go back</a>
+              <a href={home}>Go back</a>
             </p>
           </main>
         </Layout>,
@@ -474,7 +544,7 @@ app.post("/follow", async (c) => {
               <code>@{followerHandle}</code>.
             </p>
             <p>
-              <a href="/">Go back</a>
+              <a href={home}>Go back</a>
             </p>
           </main>
         </Layout>,
@@ -504,7 +574,7 @@ app.post("/follow", async (c) => {
             <code>@{followerHandle}</code>.
           </p>
           <p>
-            <a href="/">Go back</a>
+            <a href={home}>Go back</a>
           </p>
         </main>
       </Layout>,
@@ -519,15 +589,95 @@ app.post("/follow", async (c) => {
             An internal server error occurred while processing your request.
           </p>
           <p>
-            <a href="/">Go back</a>
+            <a href={home}>Go back</a>
           </p>
         </main>
       </Layout>,
       500,
     );
   }
+}
+
+export const multiApp = new Hono<InstanceEnv>();
+
+multiApp.get("/", (c) => {
+  const { instance } = c.env;
+  const url = new URL(c.req.url);
+  const cssFilename = instance.pages.color === "azure"
+    ? `pico.min.css`
+    : `pico.${instance.pages.color}.min.css`;
+  const bots = [...instance.bots];
+  return c.html(
+    <html>
+      <head>
+        <meta charset="utf-8" />
+        <title>{url.host}</title>
+        <link
+          rel="stylesheet"
+          href={`https://cdn.jsdelivr.net/npm/@picocss/pico@2/css/${cssFilename}`}
+        />
+        <style dangerouslySetInnerHTML={{ __html: instance.pages.css }} />
+      </head>
+      <body>
+        <header class="container">
+          <h1>{url.host}</h1>
+        </header>
+        <main class="container">
+          <ul>
+            {bots.map((bot) => (
+              <li>
+                <a href={`/@${encodeURIComponent(bot.username)}`}>
+                  {bot.name ?? bot.username}
+                </a>{" "}
+                <span style="user-select: all;">
+                  @{bot.username}@{url.host}
+                </span>
+              </li>
+            ))}
+          </ul>
+        </main>
+      </body>
+    </html>,
+  );
 });
 
+/**
+ * Resolves the bot a multi-bot page belongs to, and delegates to the given
+ * page handler with the bot's base path.
+ */
+function withBot(
+  page: (
+    c: PageContext,
+    bot: BotImpl<unknown>,
+    contextData: unknown,
+    base: string,
+  ) => Promise<Response>,
+): (c: HonoContext<InstanceEnv>) => Promise<Response> {
+  return async (c) => {
+    const { instance, contextData } = c.env;
+    const username = c.req.param("handle")?.slice(1);
+    if (username == null) return c.notFound();
+    const ctx = instance.federation.createContext(c.req.raw, contextData);
+    const bot = await instance.resolveBotByUsername(ctx, username);
+    if (bot == null) return c.notFound();
+    return await page(
+      c,
+      bot,
+      contextData,
+      `/@${encodeURIComponent(username)}`,
+    );
+  };
+}
+
+const handlePattern = ":handle{@[^/]+}";
+
+multiApp.get(`/${handlePattern}`, withBot(profilePage));
+multiApp.get(`/${handlePattern}/followers`, withBot(followersPage));
+multiApp.get(`/${handlePattern}/tags/:hashtag`, withBot(hashtagPage));
+multiApp.get(`/${handlePattern}/feed.xml`, withBot(feedPage));
+multiApp.post(`/${handlePattern}/follow`, withBot(followPage));
+multiApp.get(`/${handlePattern}/:id`, withBot(messagePage));
+
 interface GetPostsOptions {
   readonly hashtag?: string;
   readonly offset?: Temporal.Instant;
diff --git a/packages/botkit/src/repository.test.ts b/packages/botkit/src/repository.test.ts
index 0376526..d44392e 100644
--- a/packages/botkit/src/repository.test.ts
+++ b/packages/botkit/src/repository.test.ts
@@ -13,16 +13,22 @@
 //
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
-import { MemoryKvStore } from "@fedify/fedify/federation";
-import { importJwk } from "@fedify/fedify/sig";
+import {
+  type KvStoreListEntry,
+  MemoryKvStore,
+} from "@fedify/fedify/federation";
+import { exportJwk, importJwk } from "@fedify/fedify/sig";
 import { Create, Follow, Note, Person, PUBLIC_COLLECTION } from "@fedify/vocab";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import {
+  type KvKey,
   KvRepository,
+  type KvStore,
   MemoryCachedRepository,
   MemoryRepository,
   type Repository,
+  type Uuid,
 } from "./repository.ts";
 
 function createKvRepository(): Repository {
@@ -104,30 +110,33 @@ for (const name in factories) {
     const repo = factory();
 
     test("key pairs", async () => {
-      assert.deepStrictEqual(await repo.getKeyPairs(), undefined);
-      await repo.setKeyPairs(keyPairs);
-      assert.deepStrictEqual(await repo.getKeyPairs(), keyPairs);
+      assert.deepStrictEqual(await repo.getKeyPairs("bot"), undefined);
+      await repo.setKeyPairs("bot", keyPairs);
+      assert.deepStrictEqual(await repo.getKeyPairs("bot"), keyPairs);
     });
 
     test("messages", async () => {
-      assert.deepStrictEqual(await repo.countMessages(), 0);
+      assert.deepStrictEqual(await repo.countMessages("bot"), 0);
       assert.deepStrictEqual(
-        await repo.getMessage("01941f29-7c00-7fe8-ab0a-7b593990a3c0"),
+        await repo.getMessage("bot", "01941f29-7c00-7fe8-ab0a-7b593990a3c0"),
         undefined,
       );
       assert.deepStrictEqual(
-        await repo.getMessage("0194244f-d800-7873-8993-ef71ccd47306"),
+        await repo.getMessage("bot", "0194244f-d800-7873-8993-ef71ccd47306"),
         undefined,
       );
       assert.deepStrictEqual(
-        await repo.getMessage("01942976-3400-7f34-872e-2cbf0f9eeac4"),
+        await repo.getMessage("bot", "01942976-3400-7f34-872e-2cbf0f9eeac4"),
         undefined,
       );
       assert.deepStrictEqual(
-        await repo.getMessage("01942e9c-9000-7480-a553-7a6ce737ce14"),
+        await repo.getMessage("bot", "01942e9c-9000-7480-a553-7a6ce737ce14"),
         undefined,
       );
-      assert.deepStrictEqual(await Array.fromAsync(repo.getMessages()), []);
+      assert.deepStrictEqual(
+        await Array.fromAsync(repo.getMessages("bot")),
+        [],
+      );
 
       const messageA = new Create({
         id: new URL(
@@ -227,93 +236,129 @@ for (const name in factories) {
         updated: Temporal.Instant.from("2025-01-03T12:00:00Z"),
       });
 
-      await repo.addMessage("01941f29-7c00-7fe8-ab0a-7b593990a3c0", messageA);
-      assert.deepStrictEqual(await repo.countMessages(), 1);
+      await repo.addMessage(
+        "bot",
+        "01941f29-7c00-7fe8-ab0a-7b593990a3c0",
+        messageA,
+      );
+      assert.deepStrictEqual(await repo.countMessages("bot"), 1);
       assert.deepStrictEqual(
-        await (await repo.getMessage("01941f29-7c00-7fe8-ab0a-7b593990a3c0"))
+        await (await repo.getMessage(
+          "bot",
+          "01941f29-7c00-7fe8-ab0a-7b593990a3c0",
+        ))
           ?.toJsonLd(),
         await messageA.toJsonLd(),
       );
       assert.deepStrictEqual(
-        await repo.getMessage("0194244f-d800-7873-8993-ef71ccd47306"),
+        await repo.getMessage("bot", "0194244f-d800-7873-8993-ef71ccd47306"),
         undefined,
       );
       assert.deepStrictEqual(
-        await repo.getMessage("01942976-3400-7f34-872e-2cbf0f9eeac4"),
+        await repo.getMessage("bot", "01942976-3400-7f34-872e-2cbf0f9eeac4"),
         undefined,
       );
       assert.deepStrictEqual(
-        await repo.getMessage("01942e9c-9000-7480-a553-7a6ce737ce14"),
+        await repo.getMessage("bot", "01942e9c-9000-7480-a553-7a6ce737ce14"),
         undefined,
       );
       assert.deepStrictEqual(
         await Promise.all(
-          (await Array.fromAsync(repo.getMessages())).map((m) => m.toJsonLd()),
+          (await Array.fromAsync(repo.getMessages("bot"))).map((m) =>
+            m.toJsonLd()
+          ),
         ),
         [await messageA.toJsonLd()],
       );
 
-      await repo.addMessage("0194244f-d800-7873-8993-ef71ccd47306", messageB);
-      assert.deepStrictEqual(await repo.countMessages(), 2);
+      await repo.addMessage(
+        "bot",
+        "0194244f-d800-7873-8993-ef71ccd47306",
+        messageB,
+      );
+      assert.deepStrictEqual(await repo.countMessages("bot"), 2);
       assert.deepStrictEqual(
-        await (await repo.getMessage("01941f29-7c00-7fe8-ab0a-7b593990a3c0"))
+        await (await repo.getMessage(
+          "bot",
+          "01941f29-7c00-7fe8-ab0a-7b593990a3c0",
+        ))
           ?.toJsonLd(),
         await messageA.toJsonLd(),
       );
       assert.deepStrictEqual(
-        await (await repo.getMessage("0194244f-d800-7873-8993-ef71ccd47306"))
+        await (await repo.getMessage(
+          "bot",
+          "0194244f-d800-7873-8993-ef71ccd47306",
+        ))
           ?.toJsonLd(),
         await messageB.toJsonLd(),
       );
       assert.deepStrictEqual(
-        await repo.getMessage("01942976-3400-7f34-872e-2cbf0f9eeac4"),
+        await repo.getMessage("bot", "01942976-3400-7f34-872e-2cbf0f9eeac4"),
         undefined,
       );
       assert.deepStrictEqual(
-        await repo.getMessage("01942e9c-9000-7480-a553-7a6ce737ce14"),
+        await repo.getMessage("bot", "01942e9c-9000-7480-a553-7a6ce737ce14"),
         undefined,
       );
       assert.deepStrictEqual(
         await Promise.all(
-          (await Array.fromAsync(repo.getMessages())).map((m) => m.toJsonLd()),
+          (await Array.fromAsync(repo.getMessages("bot"))).map((m) =>
+            m.toJsonLd()
+          ),
         ),
         [await messageB.toJsonLd(), await messageA.toJsonLd()],
       );
       assert.deepStrictEqual(
         await Promise.all(
-          (await Array.fromAsync(repo.getMessages({ order: "oldest" }))).map((
-            m,
-          ) => m.toJsonLd()),
+          (await Array.fromAsync(repo.getMessages("bot", { order: "oldest" })))
+            .map((
+              m,
+            ) => m.toJsonLd()),
         ),
         [await messageA.toJsonLd(), await messageB.toJsonLd()],
       );
 
-      await repo.addMessage("01942976-3400-7f34-872e-2cbf0f9eeac4", messageC);
-      assert.deepStrictEqual(await repo.countMessages(), 3);
+      await repo.addMessage(
+        "bot",
+        "01942976-3400-7f34-872e-2cbf0f9eeac4",
+        messageC,
+      );
+      assert.deepStrictEqual(await repo.countMessages("bot"), 3);
       assert.deepStrictEqual(
-        await (await repo.getMessage("01941f29-7c00-7fe8-ab0a-7b593990a3c0"))
+        await (await repo.getMessage(
+          "bot",
+          "01941f29-7c00-7fe8-ab0a-7b593990a3c0",
+        ))
           ?.toJsonLd(),
         await messageA.toJsonLd(),
       );
       assert.deepStrictEqual(
-        await (await repo.getMessage("0194244f-d800-7873-8993-ef71ccd47306"))
+        await (await repo.getMessage(
+          "bot",
+          "0194244f-d800-7873-8993-ef71ccd47306",
+        ))
           ?.toJsonLd(),
         await messageB.toJsonLd(),
       );
       assert.deepStrictEqual(
-        await (await repo.getMessage("01942976-3400-7f34-872e-2cbf0f9eeac4"))
+        await (await repo.getMessage(
+          "bot",
+          "01942976-3400-7f34-872e-2cbf0f9eeac4",
+        ))
           ?.toJsonLd(),
         await messageC.toJsonLd(),
       );
       assert.deepStrictEqual(
-        await repo.getMessage("01942e9c-9000-7480-a553-7a6ce737ce14"),
+        await repo.getMessage("bot", "01942e9c-9000-7480-a553-7a6ce737ce14"),
         undefined,
       );
       assert.deepStrictEqual(
         await Promise.all(
-          (await Array.fromAsync(repo.getMessages({ order: "newest" }))).map((
-            m,
-          ) => m.toJsonLd()),
+          (await Array.fromAsync(repo.getMessages("bot", { order: "newest" })))
+            .map((
+              m,
+            ) => m.toJsonLd()),
         ),
         [
           await messageC.toJsonLd(),
@@ -323,9 +368,10 @@ for (const name in factories) {
       );
       assert.deepStrictEqual(
         await Promise.all(
-          (await Array.fromAsync(repo.getMessages({ order: "oldest" }))).map((
-            m,
-          ) => m.toJsonLd()),
+          (await Array.fromAsync(repo.getMessages("bot", { order: "oldest" })))
+            .map((
+              m,
+            ) => m.toJsonLd()),
         ),
         [
           await messageA.toJsonLd(),
@@ -334,31 +380,47 @@ for (const name in factories) {
         ],
       );
 
-      await repo.addMessage("01942e9c-9000-7480-a553-7a6ce737ce14", messageD);
-      assert.deepStrictEqual(await repo.countMessages(), 4);
+      await repo.addMessage(
+        "bot",
+        "01942e9c-9000-7480-a553-7a6ce737ce14",
+        messageD,
+      );
+      assert.deepStrictEqual(await repo.countMessages("bot"), 4);
       assert.deepStrictEqual(
-        await (await repo.getMessage("01941f29-7c00-7fe8-ab0a-7b593990a3c0"))
+        await (await repo.getMessage(
+          "bot",
+          "01941f29-7c00-7fe8-ab0a-7b593990a3c0",
+        ))
           ?.toJsonLd(),
         await messageA.toJsonLd(),
       );
       assert.deepStrictEqual(
-        await (await repo.getMessage("0194244f-d800-7873-8993-ef71ccd47306"))
+        await (await repo.getMessage(
+          "bot",
+          "0194244f-d800-7873-8993-ef71ccd47306",
+        ))
           ?.toJsonLd(),
         await messageB.toJsonLd(),
       );
       assert.deepStrictEqual(
-        await (await repo.getMessage("01942976-3400-7f34-872e-2cbf0f9eeac4"))
+        await (await repo.getMessage(
+          "bot",
+          "01942976-3400-7f34-872e-2cbf0f9eeac4",
+        ))
           ?.toJsonLd(),
         await messageC.toJsonLd(),
       );
       assert.deepStrictEqual(
-        await (await repo.getMessage("01942e9c-9000-7480-a553-7a6ce737ce14"))
+        await (await repo.getMessage(
+          "bot",
+          "01942e9c-9000-7480-a553-7a6ce737ce14",
+        ))
           ?.toJsonLd(),
         await messageD.toJsonLd(),
       );
       assert.deepStrictEqual(
         await Promise.all(
-          (await Array.fromAsync(repo.getMessages())).map((
+          (await Array.fromAsync(repo.getMessages("bot"))).map((
             m,
           ) => m.toJsonLd()),
         ),
@@ -372,7 +434,7 @@ for (const name in factories) {
       assert.deepStrictEqual(
         await Promise.all(
           (await Array.fromAsync(
-            repo.getMessages({
+            repo.getMessages("bot", {
               order: "oldest",
               until: Temporal.Instant.from("2025-01-03T00:00:00Z"),
             }),
@@ -387,7 +449,7 @@ for (const name in factories) {
       assert.deepStrictEqual(
         await Promise.all(
           (await Array.fromAsync(
-            repo.getMessages({
+            repo.getMessages("bot", {
               since: Temporal.Instant.from("2025-01-02T00:00:00Z"),
             }),
           )).map((m) => m.toJsonLd()),
@@ -401,7 +463,7 @@ for (const name in factories) {
       assert.deepStrictEqual(
         await Promise.all(
           (await Array.fromAsync(
-            repo.getMessages({
+            repo.getMessages("bot", {
               until: Temporal.Instant.from("2025-01-03T00:00:00Z"),
               since: Temporal.Instant.from("2025-01-02T00:00:00Z"),
             }),
@@ -414,37 +476,48 @@ for (const name in factories) {
       );
 
       const removed = await repo.removeMessage(
+        "bot",
         "0194244f-d800-7873-8993-ef71ccd47306",
       );
       assert.deepStrictEqual(
         await removed?.toJsonLd(),
         await messageB.toJsonLd(),
       );
-      assert.deepStrictEqual(await repo.countMessages(), 3);
+      assert.deepStrictEqual(await repo.countMessages("bot"), 3);
       assert.deepStrictEqual(
-        await (await repo.getMessage("01941f29-7c00-7fe8-ab0a-7b593990a3c0"))
+        await (await repo.getMessage(
+          "bot",
+          "01941f29-7c00-7fe8-ab0a-7b593990a3c0",
+        ))
           ?.toJsonLd(),
         await messageA.toJsonLd(),
       );
       assert.deepStrictEqual(
-        await repo.getMessage("0194244f-d800-7873-8993-ef71ccd47306"),
+        await repo.getMessage("bot", "0194244f-d800-7873-8993-ef71ccd47306"),
         undefined,
       );
       assert.deepStrictEqual(
-        await (await repo.getMessage("01942976-3400-7f34-872e-2cbf0f9eeac4"))
+        await (await repo.getMessage(
+          "bot",
+          "01942976-3400-7f34-872e-2cbf0f9eeac4",
+        ))
           ?.toJsonLd(),
         await messageC.toJsonLd(),
       );
       assert.deepStrictEqual(
-        await (await repo.getMessage("01942e9c-9000-7480-a553-7a6ce737ce14"))
+        await (await repo.getMessage(
+          "bot",
+          "01942e9c-9000-7480-a553-7a6ce737ce14",
+        ))
           ?.toJsonLd(),
         await messageD.toJsonLd(),
       );
       assert.deepStrictEqual(
         await Promise.all(
-          (await Array.fromAsync(repo.getMessages({ order: "newest" }))).map((
-            m,
-          ) => m.toJsonLd()),
+          (await Array.fromAsync(repo.getMessages("bot", { order: "newest" })))
+            .map((
+              m,
+            ) => m.toJsonLd()),
         ),
         [
           await messageD.toJsonLd(),
@@ -454,9 +527,10 @@ for (const name in factories) {
       );
       assert.deepStrictEqual(
         await Promise.all(
-          (await Array.fromAsync(repo.getMessages({ order: "oldest" }))).map((
-            m,
-          ) => m.toJsonLd()),
+          (await Array.fromAsync(repo.getMessages("bot", { order: "oldest" })))
+            .map((
+              m,
+            ) => m.toJsonLd()),
         ),
         [
           await messageA.toJsonLd(),
@@ -466,6 +540,7 @@ for (const name in factories) {
       );
 
       await repo.updateMessage(
+        "bot",
         "01942976-3400-7f34-872e-2cbf0f9eeac4",
         async (messageC) =>
           messageC.clone({
@@ -473,29 +548,39 @@ for (const name in factories) {
             updated: messageC2.updated,
           }),
       );
-      assert.deepStrictEqual(await repo.countMessages(), 3);
+      assert.deepStrictEqual(await repo.countMessages("bot"), 3);
       assert.deepStrictEqual(
-        await (await repo.getMessage("01941f29-7c00-7fe8-ab0a-7b593990a3c0"))
+        await (await repo.getMessage(
+          "bot",
+          "01941f29-7c00-7fe8-ab0a-7b593990a3c0",
+        ))
           ?.toJsonLd(),
         await messageA.toJsonLd(),
       );
       assert.deepStrictEqual(
-        await repo.getMessage("0194244f-d800-7873-8993-ef71ccd47306"),
+        await repo.getMessage("bot", "0194244f-d800-7873-8993-ef71ccd47306"),
         undefined,
       );
       assert.deepStrictEqual(
-        await (await repo.getMessage("01942976-3400-7f34-872e-2cbf0f9eeac4"))
+        await (await repo.getMessage(
+          "bot",
+          "01942976-3400-7f34-872e-2cbf0f9eeac4",
+        ))
           ?.toJsonLd(),
         await messageC2.toJsonLd(),
       );
       assert.deepStrictEqual(
-        await (await repo.getMessage("01942e9c-9000-7480-a553-7a6ce737ce14"))
+        await (await repo.getMessage(
+          "bot",
+          "01942e9c-9000-7480-a553-7a6ce737ce14",
+        ))
           ?.toJsonLd(),
         await messageD.toJsonLd(),
       );
 
       let updaterCalled = false;
       const updated = await repo.updateMessage(
+        "bot",
         "00000000-0000-0000-0000-000000000000",
         (message) => {
           updaterCalled = true;
@@ -504,49 +589,68 @@ for (const name in factories) {
       );
       assert.deepStrictEqual(updated, false);
       assert.deepStrictEqual(updaterCalled, false);
-      assert.deepStrictEqual(await repo.countMessages(), 3);
+      assert.deepStrictEqual(await repo.countMessages("bot"), 3);
       assert.deepStrictEqual(
-        await (await repo.getMessage("01941f29-7c00-7fe8-ab0a-7b593990a3c0"))
+        await (await repo.getMessage(
+          "bot",
+          "01941f29-7c00-7fe8-ab0a-7b593990a3c0",
+        ))
           ?.toJsonLd(),
         await messageA.toJsonLd(),
       );
       assert.deepStrictEqual(
-        await repo.getMessage("0194244f-d800-7873-8993-ef71ccd47306"),
+        await repo.getMessage("bot", "0194244f-d800-7873-8993-ef71ccd47306"),
         undefined,
       );
       assert.deepStrictEqual(
-        await (await repo.getMessage("01942976-3400-7f34-872e-2cbf0f9eeac4"))
+        await (await repo.getMessage(
+          "bot",
+          "01942976-3400-7f34-872e-2cbf0f9eeac4",
+        ))
           ?.toJsonLd(),
         await messageC2.toJsonLd(),
       );
       assert.deepStrictEqual(
-        await (await repo.getMessage("01942e9c-9000-7480-a553-7a6ce737ce14"))
+        await (await repo.getMessage(
+          "bot",
+          "01942e9c-9000-7480-a553-7a6ce737ce14",
+        ))
           ?.toJsonLd(),
         await messageD.toJsonLd(),
       );
 
       const updated2 = await repo.updateMessage(
+        "bot",
         "01942e9c-9000-7480-a553-7a6ce737ce14",
         (_) => undefined,
       );
       assert.deepStrictEqual(updated2, false);
-      assert.deepStrictEqual(await repo.countMessages(), 3);
+      assert.deepStrictEqual(await repo.countMessages("bot"), 3);
       assert.deepStrictEqual(
-        await (await repo.getMessage("01941f29-7c00-7fe8-ab0a-7b593990a3c0"))
+        await (await repo.getMessage(
+          "bot",
+          "01941f29-7c00-7fe8-ab0a-7b593990a3c0",
+        ))
           ?.toJsonLd(),
         await messageA.toJsonLd(),
       );
       assert.deepStrictEqual(
-        await repo.getMessage("0194244f-d800-7873-8993-ef71ccd47306"),
+        await repo.getMessage("bot", "0194244f-d800-7873-8993-ef71ccd47306"),
         undefined,
       );
       assert.deepStrictEqual(
-        await (await repo.getMessage("01942976-3400-7f34-872e-2cbf0f9eeac4"))
+        await (await repo.getMessage(
+          "bot",
+          "01942976-3400-7f34-872e-2cbf0f9eeac4",
+        ))
           ?.toJsonLd(),
         await messageC2.toJsonLd(),
       );
       assert.deepStrictEqual(
-        await (await repo.getMessage("01942e9c-9000-7480-a553-7a6ce737ce14"))
+        await (await repo.getMessage(
+          "bot",
+          "01942e9c-9000-7480-a553-7a6ce737ce14",
+        ))
           ?.toJsonLd(),
         await messageD.toJsonLd(),
       );
@@ -568,70 +672,95 @@ for (const name in factories) {
         "https://example.com/ap/follow/8b76286d-5eef-4f02-8a16-080ff2b0e2ca",
       );
 
-      assert.deepStrictEqual(await repo.countFollowers(), 0);
-      assert.deepStrictEqual(await repo.hasFollower(followerA.id!), false);
-      assert.deepStrictEqual(await repo.hasFollower(followerB.id!), false);
-      assert.deepStrictEqual(await Array.fromAsync(repo.getFollowers()), []);
+      assert.deepStrictEqual(await repo.countFollowers("bot"), 0);
+      assert.deepStrictEqual(
+        await repo.hasFollower("bot", followerA.id!),
+        false,
+      );
+      assert.deepStrictEqual(
+        await repo.hasFollower("bot", followerB.id!),
+        false,
+      );
+      assert.deepStrictEqual(
+        await Array.fromAsync(repo.getFollowers("bot")),
+        [],
+      );
 
-      await repo.addFollower(followFromA, followerA);
-      assert.deepStrictEqual(await repo.countFollowers(), 1);
-      assert.ok(await repo.hasFollower(followerA.id!));
-      assert.deepStrictEqual(await repo.hasFollower(followerB.id!), false);
+      await repo.addFollower("bot", followFromA, followerA);
+      assert.deepStrictEqual(await repo.countFollowers("bot"), 1);
+      assert.ok(await repo.hasFollower("bot", followerA.id!));
+      assert.deepStrictEqual(
+        await repo.hasFollower("bot", followerB.id!),
+        false,
+      );
       assert.deepStrictEqual(
         await Promise.all(
-          (await Array.fromAsync(repo.getFollowers())).map((f) => f.toJsonLd()),
+          (await Array.fromAsync(repo.getFollowers("bot"))).map((f) =>
+            f.toJsonLd()
+          ),
         ),
         [await followerA.toJsonLd()],
       );
 
-      await repo.addFollower(followFromB, followerB);
-      assert.deepStrictEqual(await repo.countFollowers(), 2);
-      assert.ok(await repo.hasFollower(followerA.id!));
-      assert.ok(await repo.hasFollower(followerB.id!));
+      await repo.addFollower("bot", followFromB, followerB);
+      assert.deepStrictEqual(await repo.countFollowers("bot"), 2);
+      assert.ok(await repo.hasFollower("bot", followerA.id!));
+      assert.ok(await repo.hasFollower("bot", followerB.id!));
       assert.deepStrictEqual(
         await Promise.all(
-          (await Array.fromAsync(repo.getFollowers())).map((f) => f.toJsonLd()),
+          (await Array.fromAsync(repo.getFollowers("bot"))).map((f) =>
+            f.toJsonLd()
+          ),
         ),
         [await followerA.toJsonLd(), await followerB.toJsonLd()],
       );
       assert.deepStrictEqual(
         await Promise.all(
-          (await Array.fromAsync(repo.getFollowers({ offset: 1 }))).map((f) =>
-            f.toJsonLd()
-          ),
+          (await Array.fromAsync(repo.getFollowers("bot", { offset: 1 }))).map((
+            f,
+          ) => f.toJsonLd()),
         ),
         [await followerB.toJsonLd()],
       );
       assert.deepStrictEqual(
         await Promise.all(
-          (await Array.fromAsync(repo.getFollowers({ limit: 1 }))).map((f) =>
-            f.toJsonLd()
-          ),
+          (await Array.fromAsync(repo.getFollowers("bot", { limit: 1 }))).map((
+            f,
+          ) => f.toJsonLd()),
         ),
         [await followerA.toJsonLd()],
       );
 
       assert.deepStrictEqual(
-        await repo.removeFollower(followFromA, followerB.id!),
+        await repo.removeFollower("bot", followFromA, followerB.id!),
         undefined,
       );
       assert.deepStrictEqual(
-        await repo.removeFollower(followFromB, followerA.id!),
+        await repo.removeFollower("bot", followFromB, followerA.id!),
         undefined,
       );
-      assert.deepStrictEqual(await repo.countFollowers(), 2);
-      assert.ok(await repo.hasFollower(followerA.id!));
-      assert.ok(await repo.hasFollower(followerB.id!));
+      assert.deepStrictEqual(await repo.countFollowers("bot"), 2);
+      assert.ok(await repo.hasFollower("bot", followerA.id!));
+      assert.ok(await repo.hasFollower("bot", followerB.id!));
 
-      await repo.removeFollower(followFromA, followerA.id!);
-      assert.deepStrictEqual(await repo.countFollowers(), 1);
-      assert.deepStrictEqual(await repo.hasFollower(followerA.id!), false);
-      assert.ok(await repo.hasFollower(followerB.id!));
+      await repo.removeFollower("bot", followFromA, followerA.id!);
+      assert.deepStrictEqual(await repo.countFollowers("bot"), 1);
+      assert.deepStrictEqual(
+        await repo.hasFollower("bot", followerA.id!),
+        false,
+      );
+      assert.ok(await repo.hasFollower("bot", followerB.id!));
 
-      await repo.removeFollower(followFromB, followerB.id!);
-      assert.deepStrictEqual(await repo.countFollowers(), 0);
-      assert.deepStrictEqual(await repo.hasFollower(followerA.id!), false);
-      assert.deepStrictEqual(await repo.hasFollower(followerB.id!), false);
+      await repo.removeFollower("bot", followFromB, followerB.id!);
+      assert.deepStrictEqual(await repo.countFollowers("bot"), 0);
+      assert.deepStrictEqual(
+        await repo.hasFollower("bot", followerA.id!),
+        false,
+      );
+      assert.deepStrictEqual(
+        await repo.hasFollower("bot", followerB.id!),
+        false,
+      );
     });
 
     test("sent follows", async () => {
@@ -644,20 +773,30 @@ for (const name in factories) {
       });
 
       assert.deepStrictEqual(
-        await repo.getSentFollow("03a395a2-353a-4894-afdb-2cab31a7b004"),
+        await repo.getSentFollow("bot", "03a395a2-353a-4894-afdb-2cab31a7b004"),
         undefined,
       );
 
-      await repo.addSentFollow("03a395a2-353a-4894-afdb-2cab31a7b004", follow);
+      await repo.addSentFollow(
+        "bot",
+        "03a395a2-353a-4894-afdb-2cab31a7b004",
+        follow,
+      );
       assert.deepStrictEqual(
-        await (await repo.getSentFollow("03a395a2-353a-4894-afdb-2cab31a7b004"))
+        await (await repo.getSentFollow(
+          "bot",
+          "03a395a2-353a-4894-afdb-2cab31a7b004",
+        ))
           ?.toJsonLd(),
         await follow.toJsonLd(),
       );
 
-      await repo.removeSentFollow("03a395a2-353a-4894-afdb-2cab31a7b004");
+      await repo.removeSentFollow(
+        "bot",
+        "03a395a2-353a-4894-afdb-2cab31a7b004",
+      );
       assert.deepStrictEqual(
-        await repo.getSentFollow("03a395a2-353a-4894-afdb-2cab31a7b004"),
+        await repo.getSentFollow("bot", "03a395a2-353a-4894-afdb-2cab31a7b004"),
         undefined,
       );
     });
@@ -672,16 +811,22 @@ for (const name in factories) {
         object: followeeId,
       });
 
-      assert.deepStrictEqual(await repo.getFollowee(followeeId), undefined);
+      assert.deepStrictEqual(
+        await repo.getFollowee("bot", followeeId),
+        undefined,
+      );
 
-      await repo.addFollowee(followeeId, follow);
+      await repo.addFollowee("bot", followeeId, follow);
       assert.deepStrictEqual(
-        await (await repo.getFollowee(followeeId))?.toJsonLd(),
+        await (await repo.getFollowee("bot", followeeId))?.toJsonLd(),
         await follow.toJsonLd(),
       );
 
-      await repo.removeFollowee(followeeId);
-      assert.deepStrictEqual(await repo.getFollowee(followeeId), undefined);
+      await repo.removeFollowee("bot", followeeId);
+      assert.deepStrictEqual(
+        await repo.getFollowee("bot", followeeId),
+        undefined,
+      );
     });
 
     test("poll voting", async () => {
@@ -692,71 +837,71 @@ for (const name in factories) {
       const voter3 = new URL("https://example.com/ap/actor/charlie");
 
       // Initially, no votes exist
-      assert.deepStrictEqual(await repo.countVoters(messageId1), 0);
-      assert.deepStrictEqual(await repo.countVotes(messageId1), {});
-      assert.deepStrictEqual(await repo.countVoters(messageId2), 0);
-      assert.deepStrictEqual(await repo.countVotes(messageId2), {});
+      assert.deepStrictEqual(await repo.countVoters("bot", messageId1), 0);
+      assert.deepStrictEqual(await repo.countVotes("bot", messageId1), {});
+      assert.deepStrictEqual(await repo.countVoters("bot", messageId2), 0);
+      assert.deepStrictEqual(await repo.countVotes("bot", messageId2), {});
 
       // Single voter, single option
-      await repo.vote(messageId1, voter1, "option1");
-      assert.deepStrictEqual(await repo.countVoters(messageId1), 1);
-      assert.deepStrictEqual(await repo.countVotes(messageId1), {
+      await repo.vote("bot", messageId1, voter1, "option1");
+      assert.deepStrictEqual(await repo.countVoters("bot", messageId1), 1);
+      assert.deepStrictEqual(await repo.countVotes("bot", messageId1), {
         "option1": 1,
       });
 
       // Same voter votes for same option again (should be ignored)
-      await repo.vote(messageId1, voter1, "option1");
-      assert.deepStrictEqual(await repo.countVoters(messageId1), 1);
-      assert.deepStrictEqual(await repo.countVotes(messageId1), {
+      await repo.vote("bot", messageId1, voter1, "option1");
+      assert.deepStrictEqual(await repo.countVoters("bot", messageId1), 1);
+      assert.deepStrictEqual(await repo.countVotes("bot", messageId1), {
         "option1": 1,
       });
 
       // Same voter votes for different option (multiple choice)
-      await repo.vote(messageId1, voter1, "option2");
-      assert.deepStrictEqual(await repo.countVoters(messageId1), 1);
-      assert.deepStrictEqual(await repo.countVotes(messageId1), {
+      await repo.vote("bot", messageId1, voter1, "option2");
+      assert.deepStrictEqual(await repo.countVoters("bot", messageId1), 1);
+      assert.deepStrictEqual(await repo.countVotes("bot", messageId1), {
         "option1": 1,
         "option2": 1,
       });
 
       // Different voter votes for same option
-      await repo.vote(messageId1, voter2, "option1");
-      assert.deepStrictEqual(await repo.countVoters(messageId1), 2);
-      assert.deepStrictEqual(await repo.countVotes(messageId1), {
+      await repo.vote("bot", messageId1, voter2, "option1");
+      assert.deepStrictEqual(await repo.countVoters("bot", messageId1), 2);
+      assert.deepStrictEqual(await repo.countVotes("bot", messageId1), {
         "option1": 2,
         "option2": 1,
       });
 
       // Third voter votes for new option
-      await repo.vote(messageId1, voter3, "option3");
-      assert.deepStrictEqual(await repo.countVoters(messageId1), 3);
-      assert.deepStrictEqual(await repo.countVotes(messageId1), {
+      await repo.vote("bot", messageId1, voter3, "option3");
+      assert.deepStrictEqual(await repo.countVoters("bot", messageId1), 3);
+      assert.deepStrictEqual(await repo.countVotes("bot", messageId1), {
         "option1": 2,
         "option2": 1,
         "option3": 1,
       });
 
       // Votes for different message should be separate
-      await repo.vote(messageId2, voter1, "optionA");
-      await repo.vote(messageId2, voter2, "optionB");
-      assert.deepStrictEqual(await repo.countVoters(messageId2), 2);
-      assert.deepStrictEqual(await repo.countVotes(messageId2), {
+      await repo.vote("bot", messageId2, voter1, "optionA");
+      await repo.vote("bot", messageId2, voter2, "optionB");
+      assert.deepStrictEqual(await repo.countVoters("bot", messageId2), 2);
+      assert.deepStrictEqual(await repo.countVotes("bot", messageId2), {
         "optionA": 1,
         "optionB": 1,
       });
 
       // Original message votes should remain unchanged
-      assert.deepStrictEqual(await repo.countVoters(messageId1), 3);
-      assert.deepStrictEqual(await repo.countVotes(messageId1), {
+      assert.deepStrictEqual(await repo.countVoters("bot", messageId1), 3);
+      assert.deepStrictEqual(await repo.countVotes("bot", messageId1), {
         "option1": 2,
         "option2": 1,
         "option3": 1,
       });
 
       // Test with empty options (edge case)
-      await repo.vote(messageId1, voter1, "");
-      assert.deepStrictEqual(await repo.countVoters(messageId1), 3);
-      assert.deepStrictEqual(await repo.countVotes(messageId1), {
+      await repo.vote("bot", messageId1, voter1, "");
+      assert.deepStrictEqual(await repo.countVoters("bot", messageId1), 3);
+      assert.deepStrictEqual(await repo.countVotes("bot", messageId1), {
         "option1": 2,
         "option2": 1,
         "option3": 1,
@@ -765,3 +910,614 @@ for (const name in factories) {
     });
   });
 }
+
+function createNote(uuid: Uuid, actor: string): Create {
+  return new Create({
+    id: new URL(`https://example.com/ap/actor/${actor}/create/${uuid}`),
+    actor: new URL(`https://example.com/ap/actor/${actor}`),
+    to: new URL(`https://example.com/ap/actor/${actor}/followers`),
+    cc: PUBLIC_COLLECTION,
+    object: new Note({
+      id: new URL(`https://example.com/ap/actor/${actor}/note/${uuid}`),
+      attribution: new URL(`https://example.com/ap/actor/${actor}`),
+      to: new URL(`https://example.com/ap/actor/${actor}/followers`),
+      cc: PUBLIC_COLLECTION,
+      content: "Hello, world!",
+      published: Temporal.Instant.from("2025-01-01T00:00:00Z"),
+    }),
+    published: Temporal.Instant.from("2025-01-01T00:00:00Z"),
+  });
+}
+
+for (const name in factories) {
+  const factory = factories[name];
+
+  describe(`${name}: bot isolation`, () => {
+    test("key pairs are isolated by bot identifier", async () => {
+      const repo = factory();
+      await repo.setKeyPairs("botA", keyPairs);
+      assert.deepStrictEqual(await repo.getKeyPairs("botB"), undefined);
+      assert.deepStrictEqual(await repo.getKeyPairs("botA"), keyPairs);
+    });
+
+    test("messages are isolated by bot identifier", async () => {
+      const repo = factory();
+      const messageId: Uuid = "01941f29-7c00-7fe8-ab0a-7b593990a3c0";
+      const message = createNote(messageId, "botA");
+      await repo.addMessage("botA", messageId, message);
+      assert.deepStrictEqual(
+        await repo.getMessage("botB", messageId),
+        undefined,
+      );
+      assert.deepStrictEqual(await repo.countMessages("botB"), 0);
+      assert.deepStrictEqual(
+        await Array.fromAsync(repo.getMessages("botB")),
+        [],
+      );
+      assert.deepStrictEqual(await repo.countMessages("botA"), 1);
+      assert.deepStrictEqual(
+        await (await repo.getMessage("botA", messageId))?.toJsonLd(),
+        await message.toJsonLd(),
+      );
+
+      // Removing through the wrong bot identifier must not delete the message:
+      assert.deepStrictEqual(
+        await repo.removeMessage("botB", messageId),
+        undefined,
+      );
+      assert.deepStrictEqual(await repo.countMessages("botA"), 1);
+
+      // Updating through the wrong bot identifier must not touch the message:
+      let updaterCalled = false;
+      const updated = await repo.updateMessage("botB", messageId, (message) => {
+        updaterCalled = true;
+        return message;
+      });
+      assert.deepStrictEqual(updated, false);
+      assert.deepStrictEqual(updaterCalled, false);
+    });
+
+    test("followers are isolated by bot identifier", async () => {
+      const repo = factory();
+      const follower = new Person({
+        id: new URL("https://example.com/ap/actor/john"),
+        preferredUsername: "john",
+      });
+      const followId = new URL(
+        "https://example.com/ap/follow/be2da56a-0ea3-4a6a-9dff-2a1837be67e0",
+      );
+      await repo.addFollower("botA", followId, follower);
+      assert.deepStrictEqual(
+        await repo.hasFollower("botB", follower.id!),
+        false,
+      );
+      assert.deepStrictEqual(await repo.countFollowers("botB"), 0);
+      assert.deepStrictEqual(
+        await Array.fromAsync(repo.getFollowers("botB")),
+        [],
+      );
+      assert.ok(await repo.hasFollower("botA", follower.id!));
+
+      // Removing through the wrong bot identifier must not delete the follower:
+      assert.deepStrictEqual(
+        await repo.removeFollower("botB", followId, follower.id!),
+        undefined,
+      );
+      assert.ok(await repo.hasFollower("botA", follower.id!));
+    });
+
+    test("sent follows are isolated by bot identifier", async () => {
+      const repo = factory();
+      const followUuid: Uuid = "03a395a2-353a-4894-afdb-2cab31a7b004";
+      const follow = new Follow({
+        id: new URL(`https://example.com/ap/actor/botA/follow/${followUuid}`),
+        actor: new URL("https://example.com/ap/actor/botA"),
+        object: new URL("https://example.com/ap/actor/john"),
+      });
+      await repo.addSentFollow("botA", followUuid, follow);
+      assert.deepStrictEqual(
+        await repo.getSentFollow("botB", followUuid),
+        undefined,
+      );
+      assert.deepStrictEqual(
+        await repo.removeSentFollow("botB", followUuid),
+        undefined,
+      );
+      assert.deepStrictEqual(
+        await (await repo.getSentFollow("botA", followUuid))?.toJsonLd(),
+        await follow.toJsonLd(),
+      );
+    });
+
+    test("followees are isolated by bot identifier", async () => {
+      const repo = factory();
+      const followeeId = new URL("https://example.com/ap/actor/john");
+      const follow = new Follow({
+        id: new URL(
+          "https://example.com/ap/actor/botA/follow/03a395a2-353a-4894-afdb-2cab31a7b004",
+        ),
+        actor: new URL("https://example.com/ap/actor/botA"),
+        object: followeeId,
+      });
+      await repo.addFollowee("botA", followeeId, follow);
+      assert.deepStrictEqual(
+        await repo.getFollowee("botB", followeeId),
+        undefined,
+      );
+      assert.deepStrictEqual(
+        await repo.removeFollowee("botB", followeeId),
+        undefined,
+      );
+      assert.deepStrictEqual(
+        await (await repo.getFollowee("botA", followeeId))?.toJsonLd(),
+        await follow.toJsonLd(),
+      );
+    });
+
+    test("poll votes are isolated by bot identifier", async () => {
+      const repo = factory();
+      const messageId: Uuid = "01945678-1234-7890-abcd-ef0123456789";
+      const voter = new URL("https://example.com/ap/actor/alice");
+      await repo.vote("botA", messageId, voter, "option1");
+      assert.deepStrictEqual(await repo.countVoters("botB", messageId), 0);
+      assert.deepStrictEqual(await repo.countVotes("botB", messageId), {});
+      assert.deepStrictEqual(await repo.countVoters("botA", messageId), 1);
+      assert.deepStrictEqual(await repo.countVotes("botA", messageId), {
+        option1: 1,
+      });
+    });
+  });
+
+  describe(`${name}: findFollowedBots()`, () => {
+    test("yields the identifiers of bots following the given actor", async () => {
+      const repo = factory();
+      const followeeId = new URL("https://example.com/ap/actor/john");
+      const otherFolloweeId = new URL("https://example.com/ap/actor/jane");
+      const followA = new Follow({
+        id: new URL(
+          "https://example.com/ap/actor/botA/follow/03a395a2-353a-4894-afdb-2cab31a7b004",
+        ),
+        actor: new URL("https://example.com/ap/actor/botA"),
+        object: followeeId,
+      });
+      const followB = new Follow({
+        id: new URL(
+          "https://example.com/ap/actor/botB/follow/e35ff5d8-ede9-4f5e-9b83-4bfcd4c9a69c",
+        ),
+        actor: new URL("https://example.com/ap/actor/botB"),
+        object: followeeId,
+      });
+
+      assert.deepStrictEqual(
+        await Array.fromAsync(repo.findFollowedBots(followeeId)),
+        [],
+      );
+
+      await repo.addFollowee("botA", followeeId, followA);
+      await repo.addFollowee("botB", followeeId, followB);
+      const bots = await Array.fromAsync(repo.findFollowedBots(followeeId));
+      bots.sort();
+      assert.deepStrictEqual(bots, ["botA", "botB"]);
+      assert.deepStrictEqual(
+        await Array.fromAsync(repo.findFollowedBots(otherFolloweeId)),
+        [],
+      );
+
+      // Adding the same followee twice must not duplicate the identifier:
+      await repo.addFollowee("botA", followeeId, followA);
+      const bots2 = await Array.fromAsync(repo.findFollowedBots(followeeId));
+      bots2.sort();
+      assert.deepStrictEqual(bots2, ["botA", "botB"]);
+
+      await repo.removeFollowee("botA", followeeId);
+      assert.deepStrictEqual(
+        await Array.fromAsync(repo.findFollowedBots(followeeId)),
+        ["botB"],
+      );
+
+      await repo.removeFollowee("botB", followeeId);
+      assert.deepStrictEqual(
+        await Array.fromAsync(repo.findFollowedBots(followeeId)),
+        [],
+      );
+    });
+  });
+
+  describe(`${name}: forIdentifier()`, () => {
+    test("returns a repository view scoped to the given identifier", async () => {
+      const repo = factory();
+      const scoped = repo.forIdentifier("botA");
+      assert.deepStrictEqual(scoped.identifier, "botA");
+
+      // Writes through the scoped view are visible through the root:
+      const messageId: Uuid = "01941f29-7c00-7fe8-ab0a-7b593990a3c0";
+      const message = createNote(messageId, "botA");
+      await scoped.addMessage(messageId, message);
+      assert.deepStrictEqual(
+        await (await repo.getMessage("botA", messageId))?.toJsonLd(),
+        await message.toJsonLd(),
+      );
+      assert.deepStrictEqual(
+        await repo.getMessage("botB", messageId),
+        undefined,
+      );
+      assert.deepStrictEqual(await scoped.countMessages(), 1);
+
+      // Writes through the root are visible through the scoped view:
+      const follower = new Person({
+        id: new URL("https://example.com/ap/actor/john"),
+        preferredUsername: "john",
+      });
+      const followId = new URL(
+        "https://example.com/ap/follow/be2da56a-0ea3-4a6a-9dff-2a1837be67e0",
+      );
+      await repo.addFollower("botA", followId, follower);
+      assert.ok(await scoped.hasFollower(follower.id!));
+      assert.deepStrictEqual(await scoped.countFollowers(), 1);
+
+      // Key pairs round-trip through the scoped view:
+      await scoped.setKeyPairs(keyPairs);
+      assert.deepStrictEqual(await scoped.getKeyPairs(), keyPairs);
+      assert.deepStrictEqual(await repo.getKeyPairs("botA"), keyPairs);
+      assert.deepStrictEqual(await repo.getKeyPairs("botB"), undefined);
+    });
+  });
+}
+
+describe("KvRepository.migrate()", () => {
+  async function seedLegacyData(kv: MemoryKvStore): Promise<{
+    messageId: Uuid;
+    messageJson: unknown;
+    followerId: URL;
+    followRequestId: URL;
+    followeeId: URL;
+    followeeFollowJson: unknown;
+    sentFollowId: Uuid;
+    sentFollowJson: unknown;
+  }> {
+    // Simulates the key layout of BotKit 0.4 and earlier, which was not
+    // scoped by bot identifiers.
+    const messageId: Uuid = "01941f29-7c00-7fe8-ab0a-7b593990a3c0";
+    const message = createNote(messageId, "bot");
+    const messageJson = await message.toJsonLd({ format: "compact" });
+    await kv.set(["_botkit", "messages"], [messageId]);
+    await kv.set(["_botkit", "messages", messageId], messageJson);
+
+    const keyPairsData = [];
+    for (const pair of keyPairs) {
+      keyPairsData.push({
+        private: await exportJwk(pair.privateKey),
+        public: await exportJwk(pair.publicKey),
+      });
+    }
+    await kv.set(["_botkit", "keyPairs"], keyPairsData);
+
+    const follower = new Person({
+      id: new URL("https://example.com/ap/actor/john"),
+      preferredUsername: "john",
+    });
+    const followRequestId = new URL(
+      "https://example.com/ap/follow/be2da56a-0ea3-4a6a-9dff-2a1837be67e0",
+    );
+    await kv.set(["_botkit", "followers"], [follower.id!.href]);
+    await kv.set(
+      ["_botkit", "followers", follower.id!.href],
+      await follower.toJsonLd({ format: "compact" }),
+    );
+    await kv.set(
+      ["_botkit", "followRequests", followRequestId.href],
+      follower.id!.href,
+    );
+
+    const followeeId = new URL("https://example.com/ap/actor/jane");
+    const followeeFollow = new Follow({
+      id: new URL(
+        "https://example.com/ap/follow/03a395a2-353a-4894-afdb-2cab31a7b004",
+      ),
+      actor: new URL("https://example.com/ap/actor/bot"),
+      object: followeeId,
+    });
+    const followeeFollowJson = await followeeFollow.toJsonLd({
+      format: "compact",
+    });
+    await kv.set(["_botkit", "followees", followeeId.href], followeeFollowJson);
+
+    const sentFollowId: Uuid = "e35ff5d8-ede9-4f5e-9b83-4bfcd4c9a69c";
+    const sentFollow = new Follow({
+      id: new URL(`https://example.com/ap/follow/${sentFollowId}`),
+      actor: new URL("https://example.com/ap/actor/bot"),
+      object: new URL("https://example.com/ap/actor/joe"),
+    });
+    const sentFollowJson = await sentFollow.toJsonLd({ format: "compact" });
+    await kv.set(["_botkit", "follows", sentFollowId], sentFollowJson);
+
+    // Poll votes for the message:
+    await kv.set(["_botkit", "polls", messageId], ["option1", "option2"]);
+    await kv.set(["_botkit", "polls", messageId, "option1"], [
+      "https://example.com/ap/actor/alice",
+      "https://example.com/ap/actor/bob",
+    ]);
+    await kv.set(["_botkit", "polls", messageId, "option2"], [
+      "https://example.com/ap/actor/alice",
+    ]);
+
+    return {
+      messageId,
+      messageJson,
+      followerId: follower.id!,
+      followRequestId,
+      followeeId,
+      followeeFollowJson,
+      sentFollowId,
+      sentFollowJson,
+    };
+  }
+
+  test("adopts legacy unscoped data", async () => {
+    const kv = new MemoryKvStore();
+    const seed = await seedLegacyData(kv);
+    const repo = new KvRepository(kv);
+
+    await repo.migrate("bot");
+
+    assert.deepStrictEqual(await repo.getKeyPairs("bot"), keyPairs);
+    assert.deepStrictEqual(await repo.countMessages("bot"), 1);
+    assert.deepStrictEqual(
+      await (await repo.getMessage("bot", seed.messageId))?.toJsonLd({
+        format: "compact",
+      }),
+      seed.messageJson,
+    );
+    assert.deepStrictEqual(
+      (await Array.fromAsync(repo.getMessages("bot"))).length,
+      1,
+    );
+    assert.ok(await repo.hasFollower("bot", seed.followerId));
+    assert.deepStrictEqual(await repo.countFollowers("bot"), 1);
+    assert.deepStrictEqual(await repo.countVoters("bot", seed.messageId), 2);
+    assert.deepStrictEqual(await repo.countVotes("bot", seed.messageId), {
+      option1: 2,
+      option2: 1,
+    });
+
+    // Data must belong to the migrated identifier only:
+    assert.deepStrictEqual(await repo.getKeyPairs("other"), undefined);
+    assert.deepStrictEqual(await repo.countMessages("other"), 0);
+
+    // Legacy keys are kept (copy, not move), so a partially failed run can
+    // be retried without data loss:
+    assert.ok(await kv.get(["_botkit", "messages", seed.messageId]) != null);
+  });
+
+  test("is idempotent", async () => {
+    const kv = new MemoryKvStore();
+    const seed = await seedLegacyData(kv);
+    const repo = new KvRepository(kv);
+
+    await repo.migrate("bot");
+    await repo.migrate("bot");
+
+    assert.deepStrictEqual(await repo.countMessages("bot"), 1);
+    assert.deepStrictEqual(await repo.countFollowers("bot"), 1);
+
+    // A migrated message that is removed afterwards must not reappear:
+    await repo.removeMessage("bot", seed.messageId);
+    await repo.migrate("bot");
+    assert.deepStrictEqual(await repo.countMessages("bot"), 0);
+  });
+
+  test("does nothing without legacy data", async () => {
+    const kv = new MemoryKvStore();
+    const repo = new KvRepository(kv);
+    await repo.migrate("bot");
+    assert.deepStrictEqual(await repo.countMessages("bot"), 0);
+    assert.deepStrictEqual(await repo.getKeyPairs("bot"), undefined);
+  });
+
+  test("does not clobber scoped data written before migration", async () => {
+    const kv = new MemoryKvStore();
+    await seedLegacyData(kv);
+    const repo = new KvRepository(kv);
+    await repo.setKeyPairs("bot", keyPairs.slice(0, 1));
+    await repo.migrate("bot");
+    assert.deepStrictEqual(await repo.getKeyPairs("bot"), [keyPairs[0]]);
+  });
+
+  test("migrates sent follows eagerly", async () => {
+    const kv = new MemoryKvStore();
+    const seed = await seedLegacyData(kv);
+    const repo = new KvRepository(kv);
+    await repo.migrate("bot");
+
+    const follow = await repo.getSentFollow("bot", seed.sentFollowId);
+    assert.deepStrictEqual(
+      await follow?.toJsonLd({ format: "compact" }),
+      seed.sentFollowJson,
+    );
+    // Legacy keys are copied, not moved:
+    assert.ok(
+      await kv.get(["_botkit", "follows", seed.sentFollowId]) != null,
+    );
+
+    // The adoption applies only to the migrating identifier:
+    const kv2 = new MemoryKvStore();
+    const seed2 = await seedLegacyData(kv2);
+    const repo2 = new KvRepository(kv2);
+    await repo2.migrate("bot");
+    assert.deepStrictEqual(
+      await repo2.getSentFollow("other", seed2.sentFollowId),
+      undefined,
+    );
+  });
+
+  test("migrates followees eagerly with their reverse index", async () => {
+    const kv = new MemoryKvStore();
+    const seed = await seedLegacyData(kv);
+    const repo = new KvRepository(kv);
+    await repo.migrate("bot");
+
+    // The reverse index is populated by the migration itself, before any
+    // followee is individually accessed, so timeline routing works right
+    // after an upgrade:
+    assert.deepStrictEqual(
+      await Array.fromAsync(repo.findFollowedBots(seed.followeeId)),
+      ["bot"],
+    );
+    const follow = await repo.getFollowee("bot", seed.followeeId);
+    assert.deepStrictEqual(
+      await follow?.toJsonLd({ format: "compact" }),
+      seed.followeeFollowJson,
+    );
+  });
+
+  test("migrates follow requests eagerly", async () => {
+    const kv = new MemoryKvStore();
+    const seed = await seedLegacyData(kv);
+    const repo = new KvRepository(kv);
+    await repo.migrate("bot");
+
+    // removeFollower() consults the migrated follow request record:
+    const removed = await repo.removeFollower(
+      "bot",
+      seed.followRequestId,
+      seed.followerId,
+    );
+    assert.ok(removed != null);
+    assert.deepStrictEqual(
+      await repo.hasFollower("bot", seed.followerId),
+      false,
+    );
+    assert.deepStrictEqual(await repo.countFollowers("bot"), 0);
+  });
+
+  test("migrates poll options named like lock keys", async () => {
+    const kv = new MemoryKvStore();
+    const seed = await seedLegacyData(kv);
+    // Poll option names are user-controlled, so an option may collide with
+    // the transient "lock" suffix used by the message/follower index lists:
+    await kv.set(["_botkit", "polls", seed.messageId], ["lock", "open"]);
+    await kv.set(
+      ["_botkit", "polls", seed.messageId, "lock"],
+      ["https://example.com/ap/actor/voter1"],
+    );
+    await kv.set(
+      ["_botkit", "polls", seed.messageId, "open"],
+      ["https://example.com/ap/actor/voter2"],
+    );
+    const repo = new KvRepository(kv);
+    await repo.migrate("bot");
+
+    assert.deepStrictEqual(await repo.countVotes("bot", seed.messageId), {
+      lock: 1,
+      open: 1,
+    });
+  });
+
+  test("adopts legacy data for one identifier only", async () => {
+    const kv = new MemoryKvStore();
+    await seedLegacyData(kv);
+    const repo = new KvRepository(kv);
+
+    await repo.migrate("botA");
+    // A later migration for another identifier must not adopt the same
+    // legacy rows again; that would break cross-identifier isolation:
+    await repo.migrate("botB");
+
+    assert.deepStrictEqual(await repo.countMessages("botA"), 1);
+    assert.deepStrictEqual(await repo.countMessages("botB"), 0);
+    assert.deepStrictEqual(await repo.getKeyPairs("botB"), undefined);
+    assert.deepStrictEqual(await repo.countFollowers("botB"), 0);
+  });
+
+  test("claims the legacy data atomically under concurrency", async () => {
+    // Slows reads down so that two concurrent migrations overlap on the
+    // missing-marker check; the CAS-backed claim must still admit only one:
+    class SlowKvStore implements KvStore {
+      readonly #inner = new MemoryKvStore();
+      async get<T = unknown>(key: KvKey): Promise<T | undefined> {
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        return await this.#inner.get<T>(key);
+      }
+      set(key: KvKey, value: unknown): Promise<void> {
+        return this.#inner.set(key, value);
+      }
+      delete(key: KvKey): Promise<void> {
+        return this.#inner.delete(key);
+      }
+      cas(
+        key: KvKey,
+        expectedValue: unknown,
+        newValue: unknown,
+      ): Promise<boolean> {
+        return this.#inner.cas!(key, expectedValue, newValue);
+      }
+      list(prefix?: KvKey): AsyncIterable<KvStoreListEntry> {
+        return this.#inner.list(prefix);
+      }
+    }
+    const kv = new SlowKvStore();
+    // Seed legacy data through the inner store's interface:
+    const messageId: Uuid = "01941f29-7c00-7fe8-ab0a-7b593990a3c0";
+    const message = createNote(messageId, "bot");
+    await kv.set(["_botkit", "messages"], [messageId]);
+    await kv.set(
+      ["_botkit", "messages", messageId],
+      await message.toJsonLd({ format: "compact" }),
+    );
+
+    const repo = new KvRepository(kv);
+    await Promise.all([repo.migrate("botA"), repo.migrate("botB")]);
+
+    const counts = [
+      await repo.countMessages("botA"),
+      await repo.countMessages("botB"),
+    ];
+    counts.sort();
+    // Exactly one identifier adopted the legacy data:
+    assert.deepStrictEqual(counts, [0, 1]);
+  });
+
+  test("keeps the legacy data with the adopting identifier", async () => {
+    const kv = new MemoryKvStore();
+    const seed = await seedLegacyData(kv);
+    const repo = new KvRepository(kv);
+
+    await repo.migrate("botA");
+    await repo.migrate("botB");
+
+    assert.deepStrictEqual(
+      await repo.getSentFollow("botB", seed.sentFollowId),
+      undefined,
+    );
+    assert.ok(await repo.getSentFollow("botA", seed.sentFollowId) != null);
+  });
+
+  test("forwards migration through MemoryCachedRepository", async () => {
+    const kv = new MemoryKvStore();
+    const seed = await seedLegacyData(kv);
+    const repo = new MemoryCachedRepository(new KvRepository(kv));
+
+    await repo.migrate?.("bot");
+
+    assert.deepStrictEqual(await repo.getKeyPairs("bot"), keyPairs);
+    assert.deepStrictEqual(await repo.countMessages("bot"), 1);
+    assert.ok(await repo.hasFollower("bot", seed.followerId));
+    // Records keyed by UUIDs are migrated as well:
+    assert.deepStrictEqual(
+      await (await repo.getSentFollow("bot", seed.sentFollowId))?.toJsonLd({
+        format: "compact",
+      }),
+      seed.sentFollowJson,
+    );
+  });
+
+  test("does not expose legacy data before migrate() is called", async () => {
+    const kv = new MemoryKvStore();
+    const seed = await seedLegacyData(kv);
+    const repo = new KvRepository(kv);
+    assert.deepStrictEqual(
+      await repo.getSentFollow("bot", seed.sentFollowId),
+      undefined,
+    );
+  });
+});
diff --git a/packages/botkit/src/repository.ts b/packages/botkit/src/repository.ts
index 2b9a050..c88a916 100644
--- a/packages/botkit/src/repository.ts
+++ b/packages/botkit/src/repository.ts
@@ -38,31 +38,48 @@ export type Uuid = ReturnType<typeof crypto.randomUUID>;
 
 /**
  * A repository for storing bot data.
+ *
+ * Since BotKit 0.5.0, a single repository can store data for multiple bot
+ * actors hosted on the same instance.  Every method takes the identifier of
+ * the bot actor that owns the data as its first parameter, and data belonging
+ * to different identifiers are completely isolated from each other.
+ *
+ * If you deal with a single bot actor, you can use
+ * the {@link Repository.forIdentifier} method to get
+ * an {@link ActorScopedRepository} view which binds the identifier once.
  * @since 0.3.0
  */
 export interface Repository {
   /**
-   * Sets the key pairs of the bot actor.
+   * Sets the key pairs of a bot actor.
+   * @param identifier The identifier of the bot actor that owns the key pairs.
    * @param keyPairs The key pairs to set.
    */
-  setKeyPairs(keyPairs: CryptoKeyPair[]): Promise<void>;
+  setKeyPairs(identifier: string, keyPairs: CryptoKeyPair[]): Promise<void>;
 
   /**
-   * Gets the key pairs of the bot actor.
+   * Gets the key pairs of a bot actor.
+   * @param identifier The identifier of the bot actor that owns the key pairs.
    * @returns The key pairs of the bot actor. If the key pairs do not exist,
    *          `undefined` will be returned.
    */
-  getKeyPairs(): Promise<CryptoKeyPair[] | undefined>;
+  getKeyPairs(identifier: string): Promise<CryptoKeyPair[] | undefined>;
 
   /**
    * Adds a message to the repository.
+   * @param identifier The identifier of the bot actor that owns the message.
    * @param id The UUID of the message.
    * @param activity The activity to add.
    */
-  addMessage(id: Uuid, activity: Create | Announce): Promise<void>;
+  addMessage(
+    identifier: string,
+    id: Uuid,
+    activity: Create | Announce,
+  ): Promise<void>;
 
   /**
    * Updates a message in the repository.
+   * @param identifier The identifier of the bot actor that owns the message.
    * @param id The UUID of the message.
    * @param updater The function to update the message.  The function will be
    *                called with the existing message, and the return value will
@@ -75,6 +92,7 @@ export interface Repository {
    *          exist.
    */
   updateMessage(
+    identifier: string,
     id: Uuid,
     updater: (
       existing: Create | Announce,
@@ -83,120 +101,181 @@ export interface Repository {
 
   /**
    * Removes a message from the repository.
+   * @param identifier The identifier of the bot actor that owns the message.
    * @param id The UUID of the message to remove.
    * @returns The removed activity.  If the message does not exist, `undefined`
    *          will be returned.
    */
-  removeMessage(id: Uuid): Promise<Create | Announce | undefined>;
+  removeMessage(
+    identifier: string,
+    id: Uuid,
+  ): Promise<Create | Announce | undefined>;
 
   /**
    * Gets messages from the repository.
+   * @param identifier The identifier of the bot actor that owns the messages.
    * @param options The options for getting messages.
    * @returns An async iterable of message activities.
    */
   getMessages(
+    identifier: string,
     options?: RepositoryGetMessagesOptions,
   ): AsyncIterable<Create | Announce>;
 
   /**
    * Gets a message from the repository.
+   * @param identifier The identifier of the bot actor that owns the message.
    * @param id The UUID of the message to get.
    * @returns The message activity, or `undefined` if the message does not
    *          exist.
    */
-  getMessage(id: Uuid): Promise<Create | Announce | undefined>;
+  getMessage(
+    identifier: string,
+    id: Uuid,
+  ): Promise<Create | Announce | undefined>;
 
   /**
    * Counts the number of messages in the repository.
+   * @param identifier The identifier of the bot actor that owns the messages.
    * @returns The number of messages in the repository.
    */
-  countMessages(): Promise<number>;
+  countMessages(identifier: string): Promise<number>;
 
   /**
    * Adds a follower to the repository.
+   * @param identifier The identifier of the bot actor that is followed.
    * @param followId The URL of the follow request.
    * @param follower The actor who follows the bot.
    */
-  addFollower(followId: URL, follower: Actor): Promise<void>;
+  addFollower(
+    identifier: string,
+    followId: URL,
+    follower: Actor,
+  ): Promise<void>;
 
   /**
    * Removes a follower from the repository.
+   * @param identifier The identifier of the bot actor that is followed.
    * @param followId The URL of the follow request.
    * @param followerId The ID of the actor to remove.
    * @returns The removed actor.  If the follower does not exist or the follow
    *          request is not about the follower, `undefined` will be returned.
    */
-  removeFollower(followId: URL, followerId: URL): Promise<Actor | undefined>;
+  removeFollower(
+    identifier: string,
+    followId: URL,
+    followerId: URL,
+  ): Promise<Actor | undefined>;
 
   /**
    * Checks if the repository has a follower.
+   * @param identifier The identifier of the bot actor that is followed.
    * @param followerId The ID of the follower to check.
    * @returns `true` if the repository has the follower, `false` otherwise.
    */
-  hasFollower(followerId: URL): Promise<boolean>;
+  hasFollower(identifier: string, followerId: URL): Promise<boolean>;
 
   /**
    * Gets followers from the repository.
+   * @param identifier The identifier of the bot actor that is followed.
    * @param options The options for getting followers.
    * @returns An async iterable of actors who follow the bot.
    */
-  getFollowers(options?: RepositoryGetFollowersOptions): AsyncIterable<Actor>;
+  getFollowers(
+    identifier: string,
+    options?: RepositoryGetFollowersOptions,
+  ): AsyncIterable<Actor>;
 
   /**
    * Counts the number of followers in the repository.
+   * @param identifier The identifier of the bot actor that is followed.
    * @returns The number of followers in the repository.
    */
-  countFollowers(): Promise<number>;
+  countFollowers(identifier: string): Promise<number>;
 
   /**
    * Adds a sent follow request to the repository.
+   * @param identifier The identifier of the bot actor that sent the follow
+   *                   request.
    * @param id The UUID of the follow request.
    * @param follow The follow activity to add.
    */
-  addSentFollow(id: Uuid, follow: Follow): Promise<void>;
+  addSentFollow(identifier: string, id: Uuid, follow: Follow): Promise<void>;
 
   /**
    * Removes a sent follow request from the repository.
+   * @param identifier The identifier of the bot actor that sent the follow
+   *                   request.
    * @param id The UUID of the follow request to remove.
    * @returns The removed follow activity.  If the follow request does not
    *          exist, `undefined` will be returned.
    */
-  removeSentFollow(id: Uuid): Promise<Follow | undefined>;
+  removeSentFollow(identifier: string, id: Uuid): Promise<Follow | undefined>;
 
   /**
    * Gets a sent follow request from the repository.
+   * @param identifier The identifier of the bot actor that sent the follow
+   *                   request.
    * @param id The UUID of the follow request to get.
    * @returns The `Follow` activity, or `undefined` if the follow request does
    *          not exist.
    */
-  getSentFollow(id: Uuid): Promise<Follow | undefined>;
+  getSentFollow(identifier: string, id: Uuid): Promise<Follow | undefined>;
 
   /**
    * Adds a followee to the repository.
+   * @param identifier The identifier of the bot actor that follows
+   *                   the followee.
    * @param followeeId The ID of the followee to add.
    * @param follow The follow activity to add.
    */
-  addFollowee(followeeId: URL, follow: Follow): Promise<void>;
+  addFollowee(
+    identifier: string,
+    followeeId: URL,
+    follow: Follow,
+  ): Promise<void>;
 
   /**
    * Removes a followee from the repository.
+   * @param identifier The identifier of the bot actor that follows
+   *                   the followee.
    * @param followeeId The ID of the followee to remove.
    * @returns The `Follow` activity that was removed.  If the followee does not
    *          exist, `undefined` will be returned.
    */
-  removeFollowee(followeeId: URL): Promise<Follow | undefined>;
+  removeFollowee(
+    identifier: string,
+    followeeId: URL,
+  ): Promise<Follow | undefined>;
 
   /**
    * Gets a followee from the repository.
+   * @param identifier The identifier of the bot actor that follows
+   *                   the followee.
    * @param followeeId The ID of the followee to get.
    * @returns The `Follow` activity, or `undefined` if the followee does not
    *          exist.
    */
-  getFollowee(followeeId: URL): Promise<Follow | undefined>;
+  getFollowee(identifier: string, followeeId: URL): Promise<Follow | undefined>;
+
+  /**
+   * Finds the identifiers of the bot actors that follow the given actor.
+   * This is the reverse lookup of {@link Repository.getFollowee}: it answers
+   * the question “which bots on this instance follow this remote actor?”,
+   * which is used for routing incoming activities from followed actors to
+   * the right bots.
+   * @param followeeId The ID of the followee to look up.
+   * @returns An async iterable of the identifiers of the bot actors that
+   *          follow the given actor.  If no bots follow the actor, an empty
+   *          iterable will be returned.
+   * @since 0.5.0
+   */
+  findFollowedBots(followeeId: URL): AsyncIterable<string>;
 
   /**
    * Records a vote in a poll.  If the same voter had already voted for the
    * same option in a poll, the vote will be silently ignored.
+   * @param identifier The identifier of the bot actor that owns the poll.
    * @param messageId The UUID of the poll message to vote on.
    * @param voterId The ID of the voter.  It should be a URL of the actor who is
    *                voting.
@@ -206,22 +285,29 @@ export interface Repository {
    *               voting for, which is one of multiple calls to this method.
    * @since 0.3.0
    */
-  vote(messageId: Uuid, voterId: URL, option: string): Promise<void>;
+  vote(
+    identifier: string,
+    messageId: Uuid,
+    voterId: URL,
+    option: string,
+  ): Promise<void>;
 
   /**
    * Counts the number of voters in a poll.  Even if the poll allows multiple
    * selections, each voter is counted only once.
+   * @param identifier The identifier of the bot actor that owns the poll.
    * @param messageId The UUID of the poll message to count voters for.
    * @returns The number of voters in the poll.  If the poll does not exist,
    *          0 will be returned.
    * @since 0.3.0
    */
-  countVoters(messageId: Uuid): Promise<number>;
+  countVoters(identifier: string, messageId: Uuid): Promise<number>;
 
   /**
    * Counts the votes for each option in a poll.  If the poll allows multiple
    * selections, each option is counted separately, and the same voter can
    * vote for multiple options.
+   * @param identifier The identifier of the bot actor that owns the poll.
    * @param messageId The UUID of the poll message to count votes for.
    * @returns A record where the keys are the options and the values are
    *          the number of votes for each option.  If the poll does not exist,
@@ -229,7 +315,285 @@ export interface Repository {
    *          present in the record if no votes were cast for them.
    * @since 0.3.0
    */
-  countVotes(messageId: Uuid): Promise<Readonly<Record<string, number>>>;
+  countVotes(
+    identifier: string,
+    messageId: Uuid,
+  ): Promise<Readonly<Record<string, number>>>;
+
+  /**
+   * Returns a view of this repository which is scoped to the given bot actor
+   * identifier.  The returned view exposes the same operations without
+   * the `identifier` parameter.
+   * @param identifier The identifier of the bot actor to scope the view to.
+   * @returns The scoped repository view.
+   * @since 0.5.0
+   */
+  forIdentifier(identifier: string): ActorScopedRepository;
+
+  /**
+   * Migrates data stored by BotKit 0.4 or earlier, which was not scoped by
+   * bot actor identifiers, so that it belongs to the given identifier.
+   * Implementations should make this operation idempotent: calling it again
+   * after a successful migration should be a no-op.
+   *
+   * This method is optional; repositories which have no legacy data format
+   * do not need to implement it.
+   * @param identifier The identifier of the bot actor that adopts the legacy
+   *                   data.
+   * @since 0.5.0
+   */
+  migrate?(identifier: string): Promise<void>;
+}
+
+/**
+ * A view of a {@link Repository} which is scoped to a single bot actor
+ * identifier.  It exposes the same operations as {@link Repository} without
+ * the `identifier` parameter, which is bound at construction time.
+ * @since 0.5.0
+ */
+export class ActorScopedRepository {
+  /**
+   * The underlying repository.
+   */
+  readonly repository: Repository;
+
+  /**
+   * The identifier of the bot actor this view is scoped to.
+   */
+  readonly identifier: string;
+
+  /**
+   * Creates a new scoped repository view.
+   * @param repository The underlying repository.
+   * @param identifier The identifier of the bot actor to scope the view to.
+   */
+  constructor(repository: Repository, identifier: string) {
+    this.repository = repository;
+    this.identifier = identifier;
+  }
+
+  /**
+   * Sets the key pairs of the bot actor.
+   * @param keyPairs The key pairs to set.
+   */
+  setKeyPairs(keyPairs: CryptoKeyPair[]): Promise<void> {
+    return this.repository.setKeyPairs(this.identifier, keyPairs);
+  }
+
+  /**
+   * Gets the key pairs of the bot actor.
+   * @returns The key pairs of the bot actor. If the key pairs do not exist,
+   *          `undefined` will be returned.
+   */
+  getKeyPairs(): Promise<CryptoKeyPair[] | undefined> {
+    return this.repository.getKeyPairs(this.identifier);
+  }
+
+  /**
+   * Adds a message to the repository.
+   * @param id The UUID of the message.
+   * @param activity The activity to add.
+   */
+  addMessage(id: Uuid, activity: Create | Announce): Promise<void> {
+    return this.repository.addMessage(this.identifier, id, activity);
+  }
+
+  /**
+   * Updates a message in the repository.
+   * @param id The UUID of the message.
+   * @param updater The function to update the message.  See also
+   *                {@link Repository.updateMessage}.
+   * @returns `true` if the message was updated, `false` if the message does not
+   *          exist.
+   */
+  updateMessage(
+    id: Uuid,
+    updater: (
+      existing: Create | Announce,
+    ) => Create | Announce | undefined | Promise<Create | Announce | undefined>,
+  ): Promise<boolean> {
+    return this.repository.updateMessage(this.identifier, id, updater);
+  }
+
+  /**
+   * Removes a message from the repository.
+   * @param id The UUID of the message to remove.
+   * @returns The removed activity.  If the message does not exist, `undefined`
+   *          will be returned.
+   */
+  removeMessage(id: Uuid): Promise<Create | Announce | undefined> {
+    return this.repository.removeMessage(this.identifier, id);
+  }
+
+  /**
+   * Gets messages from the repository.
+   * @param options The options for getting messages.
+   * @returns An async iterable of message activities.
+   */
+  getMessages(
+    options?: RepositoryGetMessagesOptions,
+  ): AsyncIterable<Create | Announce> {
+    return this.repository.getMessages(this.identifier, options);
+  }
+
+  /**
+   * Gets a message from the repository.
+   * @param id The UUID of the message to get.
+   * @returns The message activity, or `undefined` if the message does not
+   *          exist.
+   */
+  getMessage(id: Uuid): Promise<Create | Announce | undefined> {
+    return this.repository.getMessage(this.identifier, id);
+  }
+
+  /**
+   * Counts the number of messages in the repository.
+   * @returns The number of messages in the repository.
+   */
+  countMessages(): Promise<number> {
+    return this.repository.countMessages(this.identifier);
+  }
+
+  /**
+   * Adds a follower to the repository.
+   * @param followId The URL of the follow request.
+   * @param follower The actor who follows the bot.
+   */
+  addFollower(followId: URL, follower: Actor): Promise<void> {
+    return this.repository.addFollower(this.identifier, followId, follower);
+  }
+
+  /**
+   * Removes a follower from the repository.
+   * @param followId The URL of the follow request.
+   * @param followerId The ID of the actor to remove.
+   * @returns The removed actor.  If the follower does not exist or the follow
+   *          request is not about the follower, `undefined` will be returned.
+   */
+  removeFollower(followId: URL, followerId: URL): Promise<Actor | undefined> {
+    return this.repository.removeFollower(
+      this.identifier,
+      followId,
+      followerId,
+    );
+  }
+
+  /**
+   * Checks if the repository has a follower.
+   * @param followerId The ID of the follower to check.
+   * @returns `true` if the repository has the follower, `false` otherwise.
+   */
+  hasFollower(followerId: URL): Promise<boolean> {
+    return this.repository.hasFollower(this.identifier, followerId);
+  }
+
+  /**
+   * Gets followers from the repository.
+   * @param options The options for getting followers.
+   * @returns An async iterable of actors who follow the bot.
+   */
+  getFollowers(options?: RepositoryGetFollowersOptions): AsyncIterable<Actor> {
+    return this.repository.getFollowers(this.identifier, options);
+  }
+
+  /**
+   * Counts the number of followers in the repository.
+   * @returns The number of followers in the repository.
+   */
+  countFollowers(): Promise<number> {
+    return this.repository.countFollowers(this.identifier);
+  }
+
+  /**
+   * Adds a sent follow request to the repository.
+   * @param id The UUID of the follow request.
+   * @param follow The follow activity to add.
+   */
+  addSentFollow(id: Uuid, follow: Follow): Promise<void> {
+    return this.repository.addSentFollow(this.identifier, id, follow);
+  }
+
+  /**
+   * Removes a sent follow request from the repository.
+   * @param id The UUID of the follow request to remove.
+   * @returns The removed follow activity.  If the follow request does not
+   *          exist, `undefined` will be returned.
+   */
+  removeSentFollow(id: Uuid): Promise<Follow | undefined> {
+    return this.repository.removeSentFollow(this.identifier, id);
+  }
+
+  /**
+   * Gets a sent follow request from the repository.
+   * @param id The UUID of the follow request to get.
+   * @returns The `Follow` activity, or `undefined` if the follow request does
+   *          not exist.
+   */
+  getSentFollow(id: Uuid): Promise<Follow | undefined> {
+    return this.repository.getSentFollow(this.identifier, id);
+  }
+
+  /**
+   * Adds a followee to the repository.
+   * @param followeeId The ID of the followee to add.
+   * @param follow The follow activity to add.
+   */
+  addFollowee(followeeId: URL, follow: Follow): Promise<void> {
+    return this.repository.addFollowee(this.identifier, followeeId, follow);
+  }
+
+  /**
+   * Removes a followee from the repository.
+   * @param followeeId The ID of the followee to remove.
+   * @returns The `Follow` activity that was removed.  If the followee does not
+   *          exist, `undefined` will be returned.
+   */
+  removeFollowee(followeeId: URL): Promise<Follow | undefined> {
+    return this.repository.removeFollowee(this.identifier, followeeId);
+  }
+
+  /**
+   * Gets a followee from the repository.
+   * @param followeeId The ID of the followee to get.
+   * @returns The `Follow` activity, or `undefined` if the followee does not
+   *          exist.
+   */
+  getFollowee(followeeId: URL): Promise<Follow | undefined> {
+    return this.repository.getFollowee(this.identifier, followeeId);
+  }
+
+  /**
+   * Records a vote in a poll.  If the same voter had already voted for the
+   * same option in a poll, the vote will be silently ignored.
+   * @param messageId The UUID of the poll message to vote on.
+   * @param voterId The ID of the voter.
+   * @param option The option that the voter is voting for.
+   */
+  vote(messageId: Uuid, voterId: URL, option: string): Promise<void> {
+    return this.repository.vote(this.identifier, messageId, voterId, option);
+  }
+
+  /**
+   * Counts the number of voters in a poll.  Even if the poll allows multiple
+   * selections, each voter is counted only once.
+   * @param messageId The UUID of the poll message to count voters for.
+   * @returns The number of voters in the poll.  If the poll does not exist,
+   *          0 will be returned.
+   */
+  countVoters(messageId: Uuid): Promise<number> {
+    return this.repository.countVoters(this.identifier, messageId);
+  }
+
+  /**
+   * Counts the votes for each option in a poll.
+   * @param messageId The UUID of the poll message to count votes for.
+   * @returns A record where the keys are the options and the values are
+   *          the number of votes for each option.  See also
+   *          {@link Repository.countVotes}.
+   */
+  countVotes(messageId: Uuid): Promise<Readonly<Record<string, number>>> {
+    return this.repository.countVotes(this.identifier, messageId);
+  }
 }
 
 /**
@@ -280,52 +644,17 @@ export interface RepositoryGetFollowersOptions {
 }
 
 /**
- * The prefixes for key-value store keys used by the bot.
- * @since 0.3.0
+ * Options for creating a {@link KvRepository}.
+ * @since 0.5.0
  */
-export interface KvStoreRepositoryPrefixes {
-  /**
-   * The key prefix used for storing the key pairs of the bot actor.
-   * @default `["_botkit", "keyPairs"]`
-   */
-  readonly keyPairs: KvKey;
-
-  /**
-   * The key prefix used for storing published messages.
-   * @default `["_botkit", "messages"]`
-   */
-  readonly messages: KvKey;
-
-  /**
-   * The key prefix used for storing followers.
-   * @default `["_botkit", "followers"]`
-   */
-  readonly followers: KvKey;
-
-  /**
-   * The key prefix used for storing incoming follow requests.
-   * @default `["_botkit", "followRequests"]`
-   */
-  readonly followRequests: KvKey;
-
+export interface KvRepositoryOptions {
   /**
-   * The key prefix used for storing followees.
-   * @default `["_botkit", "followees"]`
+   * The key prefix under which all BotKit data is stored.  Data belonging to
+   * a bot actor is stored under `[...prefix, "bots", identifier, ...]`, and
+   * instance-wide indices are stored under `[...prefix, "index", ...]`.
+   * @default `["_botkit"]`
    */
-  readonly followees: KvKey;
-
-  /**
-   * The key prefix used for storing outgoing follow requests.
-   * @default `["_botkit", "follows"]`
-   */
-  readonly follows: KvKey;
-
-  /**
-   * The key prefix used for storing poll votes.
-   * @default `["_botkit", "polls"]`
-   * @since 0.3.0
-   */
-  readonly polls: KvKey;
+  readonly prefix?: KvKey;
 }
 
 /**
@@ -333,14 +662,19 @@ export interface KvStoreRepositoryPrefixes {
  */
 export class KvRepository implements Repository {
   readonly kv: KvStore;
-  readonly prefixes: KvStoreRepositoryPrefixes;
+
+  /**
+   * The key prefix under which all BotKit data is stored.
+   * @since 0.5.0
+   */
+  readonly prefix: KvKey;
 
   /**
    * Creates a new key-value store repository.
    * @param kv The key-value store to use.
-   * @param prefixes The prefixes for key-value store keys.
+   * @param options The options for the repository.
    */
-  constructor(kv: KvStore, prefixes?: KvStoreRepositoryPrefixes) {
+  constructor(kv: KvStore, options: KvRepositoryOptions = {}) {
     if (kv.cas == null) {
       logger.warn(
         "The given KvStore {kv} does not support CAS operations. " +
@@ -349,19 +683,118 @@ export class KvRepository implements Repository {
       );
     }
     this.kv = kv;
-    this.prefixes = {
-      keyPairs: ["_botkit", "keyPairs"],
-      messages: ["_botkit", "messages"],
-      followers: ["_botkit", "followers"],
-      followRequests: ["_botkit", "followRequests"],
-      followees: ["_botkit", "followees"],
-      follows: ["_botkit", "follows"],
-      polls: ["_botkit", "polls"],
-      ...prefixes ?? {},
-    };
-  }
-
-  async setKeyPairs(keyPairs: CryptoKeyPair[]): Promise<void> {
+    this.prefix = options.prefix ?? ["_botkit"];
+  }
+
+  #key(identifier: string, ...rest: readonly string[]): KvKey {
+    return [...this.prefix, "bots", identifier, ...rest];
+  }
+
+  #followeeIndexKey(followeeId: URL): KvKey {
+    return [...this.prefix, "index", "followees", followeeId.href];
+  }
+
+  /**
+   * Migrates data stored by BotKit 0.4 or earlier, which was not scoped by
+   * bot actor identifiers, so that it belongs to the given identifier.
+   *
+   * The legacy data can be adopted by exactly one identifier.  The adopter
+   * is claimed atomically (through a compare-and-set operation when the
+   * underlying store supports one) before anything is copied, so that
+   * reusing the repository for another bot, even concurrently, does not
+   * adopt the same rows again.  Legacy keys are copied, not moved, and
+   * the completion is recorded last, so a partially failed run is simply
+   * retried by the adopter on the next call without data loss.  Followees
+   * are also entered into the reverse lookup index used by
+   * {@link KvRepository.findFollowedBots}.
+   *
+   * Calling this method again after a successful migration is a no-op.
+   * @param identifier The identifier of the bot actor that adopts the legacy
+   *                   data.
+   * @since 0.5.0
+   */
+  async migrate(identifier: string): Promise<void> {
+    const markerKey: KvKey = [...this.prefix, "migrated"];
+    let marker = await this.kv.get<MigrationMarker>(markerKey);
+    if (marker == null) {
+      const claim: MigrationMarker = { adopter: identifier };
+      if (this.kv.cas == null) {
+        await this.kv.set(markerKey, claim);
+        marker = claim;
+      } else if (await this.kv.cas(markerKey, undefined, claim)) {
+        marker = claim;
+      } else {
+        marker = await this.kv.get<MigrationMarker>(markerKey);
+      }
+    }
+    if (marker == null || marker.adopter !== identifier || marker.done) {
+      return;
+    }
+    logger.info(
+      "Migrating legacy repository data to bot {identifier}...",
+      { identifier },
+    );
+    const categories = [
+      "keyPairs",
+      "messages",
+      "followers",
+      "followRequests",
+      "followees",
+      "follows",
+      "polls",
+    ] as const;
+    for (const category of categories) {
+      const legacyPrefix: KvKey = [...this.prefix, category];
+      for await (const entry of this.kv.list(legacyPrefix)) {
+        const rest = entry.key.slice(this.prefix.length + 1);
+        // The lock keys of the pseudo-CAS index lists are transient.
+        // Only the message and follower lists have them, directly under
+        // the category; deeper keys (e.g. a poll option named "lock")
+        // are real data:
+        if (
+          (category === "messages" || category === "followers") &&
+          rest.length === 1 && rest[0] === "lock"
+        ) {
+          continue;
+        }
+        const scopedKey = this.#key(identifier, category, ...rest);
+        if (await this.kv.get(scopedKey) == null) {
+          await this.kv.set(scopedKey, entry.value);
+        }
+        if (category === "followees" && rest.length === 1) {
+          let followeeId: URL;
+          try {
+            followeeId = new URL(rest[0]);
+          } catch (error) {
+            // A malformed legacy key cannot be indexed; storage errors from
+            // the indexing itself must propagate so the done marker is not
+            // written and the adopter retries:
+            logger.warn(
+              "Skipping the malformed legacy followee key {followeeId}.",
+              { followeeId: rest[0], error },
+            );
+            continue;
+          }
+          await this.#addToFolloweeIndex(identifier, followeeId);
+        }
+      }
+    }
+    // The completion is recorded last so that an interrupted migration is
+    // retried on the next run:
+    await this.kv.set(
+      markerKey,
+      { adopter: identifier, done: true } satisfies MigrationMarker,
+    );
+    logger.info(
+      "Finished migrating legacy repository data to bot {identifier}.",
+      { identifier },
+    );
+  }
+
+  async setKeyPairs(
+    identifier: string,
+    keyPairs: CryptoKeyPair[],
+  ): Promise<void> {
     const pairs: KeyPair[] = [];
     for (const keyPair of keyPairs) {
       const pair: KeyPair = {
@@ -370,11 +803,13 @@ export class KvRepository implements Repository {
       };
       pairs.push(pair);
     }
-    await this.kv.set(this.prefixes.keyPairs, pairs);
+    await this.kv.set(this.#key(identifier, "keyPairs"), pairs);
   }
 
-  async getKeyPairs(): Promise<CryptoKeyPair[] | undefined> {
-    const keyPairs = await this.kv.get<KeyPair[]>(this.prefixes.keyPairs);
+  async getKeyPairs(identifier: string): Promise<CryptoKeyPair[] | undefined> {
+    const keyPairs = await this.kv.get<KeyPair[]>(
+      this.#key(identifier, "keyPairs"),
+    );
     if (keyPairs == null) return undefined;
     const promises = keyPairs.map(async (pair) => ({
       privateKey: await importJwk(pair.private, "private"),
@@ -383,14 +818,18 @@ export class KvRepository implements Repository {
     return await Promise.all(promises);
   }
 
-  async addMessage(id: Uuid, activity: Create | Announce): Promise<void> {
-    const messageKey: KvKey = [...this.prefixes.messages, id];
+  async addMessage(
+    identifier: string,
+    id: Uuid,
+    activity: Create | Announce,
+  ): Promise<void> {
+    const messageKey = this.#key(identifier, "messages", id);
     await this.kv.set(
       messageKey,
       await activity.toJsonLd({ format: "compact" }),
     );
-    const lockKey: KvKey = [...this.prefixes.messages, "lock"];
-    const listKey: KvKey = this.prefixes.messages;
+    const lockKey = this.#key(identifier, "messages", "lock");
+    const listKey = this.#key(identifier, "messages");
     do {
       await this.kv.set(lockKey, id);
       const set = new Set(await this.kv.get<string[]>(listKey) ?? []);
@@ -402,12 +841,13 @@ export class KvRepository implements Repository {
   }
 
   async updateMessage(
+    identifier: string,
     id: Uuid,
     updater: (
       existing: Create | Announce,
     ) => Create | Announce | undefined | Promise<Create | Announce | undefined>,
   ): Promise<boolean> {
-    const kvKey: KvKey = [...this.prefixes.messages, id];
+    const kvKey = this.#key(identifier, "messages", id);
     const createJson = await this.kv.get(kvKey);
     if (createJson == null) return false;
     const activity = await Activity.fromJsonLd(createJson);
@@ -423,9 +863,12 @@ export class KvRepository implements Repository {
     return true;
   }
 
-  async removeMessage(id: Uuid): Promise<Create | Announce | undefined> {
-    const listKey: KvKey = this.prefixes.messages;
-    const lockKey: KvKey = [...listKey, "lock"];
+  async removeMessage(
+    identifier: string,
+    id: Uuid,
+  ): Promise<Create | Announce | undefined> {
+    const listKey = this.#key(identifier, "messages");
+    const lockKey = this.#key(identifier, "messages", "lock");
     const lockId = `${id}:delete`;
     do {
       await this.kv.set(lockKey, lockId);
@@ -435,7 +878,7 @@ export class KvRepository implements Repository {
       list.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
       await this.kv.set(listKey, list);
     } while (await this.kv.get(lockKey) !== lockId);
-    const messageKey: KvKey = [...listKey, id];
+    const messageKey = this.#key(identifier, "messages", id);
     const activityJson = await this.kv.get(messageKey);
     if (activityJson == null) return;
     await this.kv.delete(messageKey);
@@ -447,12 +890,14 @@ export class KvRepository implements Repository {
   }
 
   async *getMessages(
+    identifier: string,
     options: RepositoryGetMessagesOptions = {},
   ): AsyncIterable<Create | Announce> {
     const { order, until, since, limit } = options;
     const untilTs = until == null ? null : until.epochMilliseconds;
     const sinceTs = since == null ? null : since.epochMilliseconds;
-    let messageIds = await this.kv.get<string[]>(this.prefixes.messages) ?? [];
+    let messageIds =
+      await this.kv.get<string[]>(this.#key(identifier, "messages")) ?? [];
     if (sinceTs != null) {
       const offset = messageIds.findIndex((id) =>
         extractTimestamp(id) >= sinceTs
@@ -472,7 +917,9 @@ export class KvRepository implements Repository {
       messageIds = messageIds.slice(0, limit);
     }
     for (const id of messageIds) {
-      const messageJson = await this.kv.get([...this.prefixes.messages, id]);
+      const messageJson = await this.kv.get(
+        this.#key(identifier, "messages", id),
+      );
       if (messageJson == null) continue;
       try {
         const activity = await Activity.fromJsonLd(messageJson);
@@ -485,8 +932,11 @@ export class KvRepository implements Repository {
     }
   }
 
-  async getMessage(id: Uuid): Promise<Create | Announce | undefined> {
-    const json = await this.kv.get([...this.prefixes.messages, id]);
+  async getMessage(
+    identifier: string,
+    id: Uuid,
+  ): Promise<Create | Announce | undefined> {
+    const json = await this.kv.get(this.#key(identifier, "messages", id));
     if (json == null) return undefined;
     let activity: Activity;
     try {
@@ -501,47 +951,54 @@ export class KvRepository implements Repository {
     return undefined;
   }
 
-  async countMessages(): Promise<number> {
-    const messageIds = await this.kv.get<string[]>(this.prefixes.messages) ??
-      [];
+  async countMessages(identifier: string): Promise<number> {
+    const messageIds =
+      await this.kv.get<string[]>(this.#key(identifier, "messages")) ?? [];
     return messageIds.length;
   }
 
-  async addFollower(followRequestId: URL, follower: Actor): Promise<void> {
+  async addFollower(
+    identifier: string,
+    followRequestId: URL,
+    follower: Actor,
+  ): Promise<void> {
     if (follower.id == null) {
       throw new TypeError("The follower ID is missing.");
     }
-    const followerKey: KvKey = [...this.prefixes.followers, follower.id.href];
+    const followerKey = this.#key(identifier, "followers", follower.id.href);
     await this.kv.set(
       followerKey,
       await follower.toJsonLd({ format: "compact" }),
     );
-    const lockKey: KvKey = [...this.prefixes.followers, "lock"];
-    const listKey: KvKey = this.prefixes.followers;
+    const lockKey = this.#key(identifier, "followers", "lock");
+    const listKey = this.#key(identifier, "followers");
     do {
       await this.kv.set(lockKey, follower.id.href);
       const list = await this.kv.get<string[]>(listKey) ?? [];
       if (!list.includes(follower.id.href)) list.push(follower.id.href);
       await this.kv.set(listKey, list);
     } while (await this.kv.get(lockKey) !== follower.id.href);
-    const followRequestKey: KvKey = [
-      ...this.prefixes.followRequests,
+    const followRequestKey = this.#key(
+      identifier,
+      "followRequests",
       followRequestId.href,
-    ];
+    );
     await this.kv.set(followRequestKey, follower.id.href);
   }
 
   async removeFollower(
+    identifier: string,
     followRequestId: URL,
     actorId: URL,
   ): Promise<Actor | undefined> {
-    const followRequestKey: KvKey = [
-      ...this.prefixes.followRequests,
+    const followRequestKey = this.#key(
+      identifier,
+      "followRequests",
       followRequestId.href,
-    ];
+    );
     const followerId = await this.kv.get<string>(followRequestKey);
     if (followerId == null) return undefined;
-    const followerKey: KvKey = [...this.prefixes.followers, followerId];
+    const followerKey = this.#key(identifier, "followers", followerId);
     if (followerId !== actorId.href) return undefined;
     const followerJson = await this.kv.get(followerKey);
     if (followerJson == null) return undefined;
@@ -552,8 +1009,8 @@ export class KvRepository implements Repository {
       return undefined;
     }
     if (!isActor(follower)) return undefined;
-    const lockKey: KvKey = [...this.prefixes.followers, "lock"];
-    const listKey: KvKey = this.prefixes.followers;
+    const lockKey = this.#key(identifier, "followers", "lock");
+    const listKey = this.#key(identifier, "followers");
     do {
       await this.kv.set(lockKey, followerId);
       let list = await this.kv.get<string[]>(listKey) ?? [];
@@ -565,25 +1022,25 @@ export class KvRepository implements Repository {
     return follower;
   }
 
-  async hasFollower(followerId: URL): Promise<boolean> {
-    return await this.kv.get<unknown>([
-      ...this.prefixes.followers,
-      followerId.href,
-    ]) != null;
+  async hasFollower(identifier: string, followerId: URL): Promise<boolean> {
+    return await this.kv.get<unknown>(
+      this.#key(identifier, "followers", followerId.href),
+    ) != null;
   }
 
   async *getFollowers(
+    identifier: string,
     options: RepositoryGetFollowersOptions = {},
   ): AsyncIterable<Actor> {
     const { offset = 0, limit } = options;
-    let followerIds = await this.kv.get<string[]>(this.prefixes.followers) ??
-      [];
+    let followerIds =
+      await this.kv.get<string[]>(this.#key(identifier, "followers")) ?? [];
     followerIds = followerIds.slice(offset);
     if (limit != null) {
       followerIds = followerIds.slice(0, limit);
     }
     for (const id of followerIds) {
-      const json = await this.kv.get([...this.prefixes.followers, id]);
+      const json = await this.kv.get(this.#key(identifier, "followers", id));
       let actor: Object;
       try {
         actor = await Object.fromJsonLd(json);
@@ -595,28 +1052,40 @@ export class KvRepository implements Repository {
     }
   }
 
-  async countFollowers(): Promise<number> {
-    const followerIds = await this.kv.get<string[]>(this.prefixes.followers) ??
-      [];
+  async countFollowers(identifier: string): Promise<number> {
+    const followerIds =
+      await this.kv.get<string[]>(this.#key(identifier, "followers")) ?? [];
     return followerIds.length;
   }
 
-  async addSentFollow(id: Uuid, follow: Follow): Promise<void> {
+  async addSentFollow(
+    identifier: string,
+    id: Uuid,
+    follow: Follow,
+  ): Promise<void> {
     await this.kv.set(
-      [...this.prefixes.follows, id],
+      this.#key(identifier, "follows", id),
       await follow.toJsonLd({ format: "compact" }),
     );
   }
 
-  async removeSentFollow(id: Uuid): Promise<Follow | undefined> {
-    const follow = await this.getSentFollow(id);
+  async removeSentFollow(
+    identifier: string,
+    id: Uuid,
+  ): Promise<Follow | undefined> {
+    const follow = await this.getSentFollow(identifier, id);
     if (follow == null) return undefined;
-    await this.kv.delete([...this.prefixes.follows, id]);
+    await this.kv.delete(this.#key(identifier, "follows", id));
     return follow;
   }
 
-  async getSentFollow(id: Uuid): Promise<Follow | undefined> {
-    const followJson = await this.kv.get([...this.prefixes.follows, id]);
+  async getSentFollow(
+    identifier: string,
+    id: Uuid,
+  ): Promise<Follow | undefined> {
+    const followJson = await this.kv.get(
+      this.#key(identifier, "follows", id),
+    );
     if (followJson == null) return undefined;
     try {
       return await Follow.fromJsonLd(followJson);
@@ -625,25 +1094,42 @@ export class KvRepository implements Repository {
     }
   }
 
-  async addFollowee(followeeId: URL, follow: Follow): Promise<void> {
+  async addFollowee(
+    identifier: string,
+    followeeId: URL,
+    follow: Follow,
+  ): Promise<void> {
     await this.kv.set(
-      [...this.prefixes.followees, followeeId.href],
+      this.#key(identifier, "followees", followeeId.href),
       await follow.toJsonLd({ format: "compact" }),
     );
-  }
-
-  async removeFollowee(followeeId: URL): Promise<Follow | undefined> {
-    const follow = await this.getFollowee(followeeId);
-    if (follow == null) return undefined;
-    await this.kv.delete([...this.prefixes.followees, followeeId.href]);
+    await this.#addToFolloweeIndex(identifier, followeeId);
+  }
+
+  async removeFollowee(
+    identifier: string,
+    followeeId: URL,
+  ): Promise<Follow | undefined> {
+    const follow = await this.getFollowee(identifier, followeeId);
+    if (follow == null) {
+      // The followee record may have been deleted by an earlier attempt that
+      // failed before cleaning up the reverse index; repair it so that
+      // retries converge.
+      await this.#removeFromFolloweeIndex(identifier, followeeId);
+      return undefined;
+    }
+    await this.kv.delete(this.#key(identifier, "followees", followeeId.href));
+    await this.#removeFromFolloweeIndex(identifier, followeeId);
     return follow;
   }
 
-  async getFollowee(followeeId: URL): Promise<Follow | undefined> {
-    const json = await this.kv.get([
-      ...this.prefixes.followees,
-      followeeId.href,
-    ]);
+  async getFollowee(
+    identifier: string,
+    followeeId: URL,
+  ): Promise<Follow | undefined> {
+    const json = await this.kv.get(
+      this.#key(identifier, "followees", followeeId.href),
+    );
     if (json == null) return undefined;
     try {
       return await Follow.fromJsonLd(json);
@@ -652,14 +1138,68 @@ export class KvRepository implements Repository {
     }
   }
 
-  async vote(messageId: Uuid, voterId: URL, option: string): Promise<void> {
-    const key: KvKey = [...this.prefixes.polls, messageId, option];
+  async *findFollowedBots(followeeId: URL): AsyncIterable<string> {
+    const identifiers = await this.kv.get<string[]>(
+      this.#followeeIndexKey(followeeId),
+    ) ?? [];
+    for (const identifier of identifiers) yield identifier;
+  }
+
+  async #addToFolloweeIndex(
+    identifier: string,
+    followeeId: URL,
+  ): Promise<void> {
+    const key = this.#followeeIndexKey(followeeId);
+    while (true) {
+      const prev = await this.kv.get<string[]>(key);
+      if (prev != null && prev.includes(identifier)) return;
+      const next = prev == null ? [identifier] : [...prev, identifier];
+      if (this.kv.cas == null) {
+        await this.kv.set(key, next);
+        return;
+      }
+      if (await this.kv.cas(key, prev, next)) return;
+      logger.trace(
+        "CAS operation failed, retrying to index followee {followeeId} for bot {identifier}.",
+        { followeeId: followeeId.href, identifier },
+      );
+    }
+  }
+
+  async #removeFromFolloweeIndex(
+    identifier: string,
+    followeeId: URL,
+  ): Promise<void> {
+    const key = this.#followeeIndexKey(followeeId);
+    while (true) {
+      const prev = await this.kv.get<string[]>(key);
+      if (prev == null || !prev.includes(identifier)) return;
+      const next = prev.filter((id) => id !== identifier);
+      if (this.kv.cas == null) {
+        await this.kv.set(key, next);
+        return;
+      }
+      if (await this.kv.cas(key, prev, next)) return;
+      logger.trace(
+        "CAS operation failed, retrying to unindex followee {followeeId} for bot {identifier}.",
+        { followeeId: followeeId.href, identifier },
+      );
+    }
+  }
+
+  async vote(
+    identifier: string,
+    messageId: Uuid,
+    voterId: URL,
+    option: string,
+  ): Promise<void> {
+    const key = this.#key(identifier, "polls", messageId, option);
     while (true) {
       const prev = await this.kv.get<string[]>(key);
       if (prev != null && prev.includes(voterId.href)) return;
       const next = prev == null ? [voterId.href] : [...prev, voterId.href];
       if (this.kv.cas == null) {
-        this.kv.set(key, next);
+        await this.kv.set(key, next);
         break;
       } else {
         const success = await this.kv.cas(key, prev, next);
@@ -675,7 +1215,7 @@ export class KvRepository implements Repository {
         );
       }
     }
-    const optionsKey: KvKey = [...this.prefixes.polls, messageId];
+    const optionsKey = this.#key(identifier, "polls", messageId);
     while (true) {
       const prevOptions = await this.kv.get<string[]>(optionsKey);
       if (prevOptions != null && prevOptions.includes(option)) return;
@@ -683,7 +1223,7 @@ export class KvRepository implements Repository {
         ? [option]
         : [...prevOptions, option];
       if (this.kv.cas == null) {
-        this.kv.set(optionsKey, nextOptions);
+        await this.kv.set(optionsKey, nextOptions);
         break;
       } else {
         const success = await this.kv.cas(optionsKey, prevOptions, nextOptions);
@@ -700,18 +1240,15 @@ export class KvRepository implements Repository {
     }
   }
 
-  async countVoters(messageId: Uuid): Promise<number> {
-    const options = await this.kv.get<string[]>([
-      ...this.prefixes.polls,
-      messageId,
-    ]) ?? [];
+  async countVoters(identifier: string, messageId: Uuid): Promise<number> {
+    const options = await this.kv.get<string[]>(
+      this.#key(identifier, "polls", messageId),
+    ) ?? [];
     const result = new Set<string>();
     for (const option of options) {
-      const voters = await this.kv.get<string[]>([
-        ...this.prefixes.polls,
-        messageId,
-        option,
-      ]);
+      const voters = await this.kv.get<string[]>(
+        this.#key(identifier, "polls", messageId, option),
+      );
       if (voters != null) {
         for (const voter of voters) result.add(voter);
       }
@@ -719,22 +1256,26 @@ export class KvRepository implements Repository {
     return result.size;
   }
 
-  async countVotes(messageId: Uuid): Promise<Readonly<Record<string, number>>> {
-    const options = await this.kv.get<string[]>([
-      ...this.prefixes.polls,
-      messageId,
-    ]) ?? [];
+  async countVotes(
+    identifier: string,
+    messageId: Uuid,
+  ): Promise<Readonly<Record<string, number>>> {
+    const options = await this.kv.get<string[]>(
+      this.#key(identifier, "polls", messageId),
+    ) ?? [];
     const result: Record<string, number> = {};
     for (const option of options) {
-      const voters = await this.kv.get<string[]>([
-        ...this.prefixes.polls,
-        messageId,
-        option,
-      ]);
+      const voters = await this.kv.get<string[]>(
+        this.#key(identifier, "polls", messageId, option),
+      );
       result[option] = voters == null ? 0 : voters.length;
     }
     return result;
   }
+
+  forIdentifier(identifier: string): ActorScopedRepository {
+    return new ActorScopedRepository(this, identifier);
+  }
 }
 
 interface KeyPair {
@@ -742,6 +1283,11 @@ interface KeyPair {
   public: JsonWebKey;
 }
 
+interface MigrationMarker {
+  adopter: string;
+  done?: boolean;
+}
+
 /**
  * Extracts the timestamp from a UUIDv7.
  * @param uuid The UUIDv7 string to extract the timestamp from.
@@ -758,58 +1304,89 @@ function extractTimestamp(uuid: string): number {
   return parseInt(timestampHex, 16);
 }
 
+interface MemoryActorData {
+  keyPairs?: CryptoKeyPair[];
+  messages: Map<Uuid, Create | Announce>;
+  followers: Map<string, Actor>;
+  followRequests: Record<string, string>;
+  sentFollows: Record<string, Follow>;
+  followees: Record<string, Follow>;
+  polls: Record<Uuid, Record<string, Set<string>>>;
+}
+
 /**
  * A repository for storing bot data in memory.  This repository is not
  * persistent and is only suitable for testing or development.
  */
 export class MemoryRepository implements Repository {
-  keyPairs?: CryptoKeyPair[];
-  messages: Map<Uuid, Create | Announce> = new Map();
-  followers: Map<string, Actor> = new Map();
-  followRequests: Record<string, string> = {};
-  sentFollows: Record<string, Follow> = {};
-  followees: Record<string, Follow> = {};
-  polls: Record<Uuid, Record<string, Set<string>>> = {};
+  #data: Map<string, MemoryActorData> = new Map();
+
+  #bucket(identifier: string): MemoryActorData {
+    let data = this.#data.get(identifier);
+    if (data == null) {
+      data = {
+        messages: new Map(),
+        followers: new Map(),
+        followRequests: {},
+        sentFollows: {},
+        followees: {},
+        polls: {},
+      };
+      this.#data.set(identifier, data);
+    }
+    return data;
+  }
 
-  setKeyPairs(keyPairs: CryptoKeyPair[]): Promise<void> {
-    this.keyPairs = keyPairs;
+  setKeyPairs(identifier: string, keyPairs: CryptoKeyPair[]): Promise<void> {
+    this.#bucket(identifier).keyPairs = keyPairs;
     return Promise.resolve();
   }
 
-  getKeyPairs(): Promise<CryptoKeyPair[] | undefined> {
-    return Promise.resolve(this.keyPairs);
+  getKeyPairs(identifier: string): Promise<CryptoKeyPair[] | undefined> {
+    return Promise.resolve(this.#data.get(identifier)?.keyPairs);
   }
 
-  addMessage(id: Uuid, activity: Create | Announce): Promise<void> {
-    this.messages.set(id, activity);
+  addMessage(
+    identifier: string,
+    id: Uuid,
+    activity: Create | Announce,
+  ): Promise<void> {
+    this.#bucket(identifier).messages.set(id, activity);
     return Promise.resolve();
   }
 
   async updateMessage(
+    identifier: string,
     id: Uuid,
     updater: (
       existing: Create | Announce,
     ) => Create | Announce | undefined | Promise<Create | Announce | undefined>,
   ): Promise<boolean> {
-    const existing = this.messages.get(id);
-    if (existing == null) return false;
+    const messages = this.#data.get(identifier)?.messages;
+    const existing = messages?.get(id);
+    if (messages == null || existing == null) return false;
     const newActivity = await updater(existing);
     if (newActivity == null) return false;
-    this.messages.set(id, newActivity);
+    messages.set(id, newActivity);
     return true;
   }
 
-  removeMessage(id: Uuid): Promise<Create | Announce | undefined> {
-    const activity = this.messages.get(id);
-    this.messages.delete(id);
+  removeMessage(
+    identifier: string,
+    id: Uuid,
+  ): Promise<Create | Announce | undefined> {
+    const messages = this.#data.get(identifier)?.messages;
+    const activity = messages?.get(id);
+    messages?.delete(id);
     return Promise.resolve(activity);
   }
 
   async *getMessages(
+    identifier: string,
     options: RepositoryGetMessagesOptions = {},
   ): AsyncIterable<Create | Announce> {
     const { order, until, since, limit } = options;
-    let messages = [...this.messages.values()];
+    let messages = [...this.#data.get(identifier)?.messages.values() ?? []];
     if (since != null) {
       messages = messages.filter((message) =>
         message.published != null &&
@@ -834,48 +1411,65 @@ export class MemoryRepository implements Repository {
       );
     }
     if (limit != null) {
-      messages.slice(0, limit);
+      messages = messages.slice(0, limit);
     }
     for (const message of messages) yield message;
   }
 
-  getMessage(id: Uuid): Promise<Create | Announce | undefined> {
-    return Promise.resolve(this.messages.get(id));
+  getMessage(
+    identifier: string,
+    id: Uuid,
+  ): Promise<Create | Announce | undefined> {
+    return Promise.resolve(this.#data.get(identifier)?.messages.get(id));
   }
 
-  countMessages(): Promise<number> {
-    return Promise.resolve(this.messages.size);
+  countMessages(identifier: string): Promise<number> {
+    return Promise.resolve(this.#data.get(identifier)?.messages.size ?? 0);
   }
 
-  addFollower(followId: URL, follower: Actor): Promise<void> {
+  addFollower(
+    identifier: string,
+    followId: URL,
+    follower: Actor,
+  ): Promise<void> {
     if (follower.id == null) {
       throw new TypeError("The follower ID is missing.");
     }
-    this.followers.set(follower.id.href, follower);
-    this.followRequests[followId.href] = follower.id.href;
+    const data = this.#bucket(identifier);
+    data.followers.set(follower.id.href, follower);
+    data.followRequests[followId.href] = follower.id.href;
     return Promise.resolve();
   }
 
-  removeFollower(followId: URL, followerId: URL): Promise<Actor | undefined> {
-    const existing = this.followRequests[followId.href];
+  removeFollower(
+    identifier: string,
+    followId: URL,
+    followerId: URL,
+  ): Promise<Actor | undefined> {
+    const data = this.#data.get(identifier);
+    if (data == null) return Promise.resolve(undefined);
+    const existing = data.followRequests[followId.href];
     if (existing == null || existing !== followerId.href) {
       return Promise.resolve(undefined);
     }
-    delete this.followRequests[followId.href];
-    const follower = this.followers.get(followerId.href);
-    this.followers.delete(followerId.href);
+    delete data.followRequests[followId.href];
+    const follower = data.followers.get(followerId.href);
+    data.followers.delete(followerId.href);
     return Promise.resolve(follower);
   }
 
-  hasFollower(followerId: URL): Promise<boolean> {
-    return Promise.resolve(this.followers.has(followerId.href));
+  hasFollower(identifier: string, followerId: URL): Promise<boolean> {
+    return Promise.resolve(
+      this.#data.get(identifier)?.followers.has(followerId.href) ?? false,
+    );
   }
 
   async *getFollowers(
+    identifier: string,
     options: RepositoryGetFollowersOptions = {},
   ): AsyncIterable<Actor> {
     const { offset = 0, limit } = options;
-    let followers = [...this.followers.values()];
+    let followers = [...this.#data.get(identifier)?.followers.values() ?? []];
     followers.sort((a, b) => b.id!.href.localeCompare(a.id!.href) ?? 0);
     if (offset > 0) {
       followers = followers.slice(offset);
@@ -888,49 +1482,76 @@ export class MemoryRepository implements Repository {
     }
   }
 
-  countFollowers(): Promise<number> {
-    return Promise.resolve(this.followers.size);
+  countFollowers(identifier: string): Promise<number> {
+    return Promise.resolve(this.#data.get(identifier)?.followers.size ?? 0);
   }
 
-  addSentFollow(id: Uuid, follow: Follow): Promise<void> {
-    this.sentFollows[id] = follow;
+  addSentFollow(identifier: string, id: Uuid, follow: Follow): Promise<void> {
+    this.#bucket(identifier).sentFollows[id] = follow;
     return Promise.resolve();
   }
 
-  removeSentFollow(id: Uuid): Promise<Follow | undefined> {
-    const follow = this.sentFollows[id];
-    delete this.sentFollows[id];
+  removeSentFollow(identifier: string, id: Uuid): Promise<Follow | undefined> {
+    const sentFollows = this.#data.get(identifier)?.sentFollows;
+    if (sentFollows == null) return Promise.resolve(undefined);
+    const follow = sentFollows[id];
+    delete sentFollows[id];
     return Promise.resolve(follow);
   }
 
-  getSentFollow(id: Uuid): Promise<Follow | undefined> {
-    return Promise.resolve(this.sentFollows[id]);
+  getSentFollow(identifier: string, id: Uuid): Promise<Follow | undefined> {
+    return Promise.resolve(this.#data.get(identifier)?.sentFollows[id]);
   }
 
-  addFollowee(followeeId: URL, follow: Follow): Promise<void> {
-    this.followees[followeeId.href] = follow;
+  addFollowee(
+    identifier: string,
+    followeeId: URL,
+    follow: Follow,
+  ): Promise<void> {
+    this.#bucket(identifier).followees[followeeId.href] = follow;
     return Promise.resolve();
   }
 
-  removeFollowee(followeeId: URL): Promise<Follow | undefined> {
-    const follow = this.followees[followeeId.href];
-    delete this.followees[followeeId.href];
+  removeFollowee(
+    identifier: string,
+    followeeId: URL,
+  ): Promise<Follow | undefined> {
+    const followees = this.#data.get(identifier)?.followees;
+    if (followees == null) return Promise.resolve(undefined);
+    const follow = followees[followeeId.href];
+    delete followees[followeeId.href];
     return Promise.resolve(follow);
   }
 
-  getFollowee(followeeId: URL): Promise<Follow | undefined> {
-    return Promise.resolve(this.followees[followeeId.href]);
+  getFollowee(
+    identifier: string,
+    followeeId: URL,
+  ): Promise<Follow | undefined> {
+    return Promise.resolve(
+      this.#data.get(identifier)?.followees[followeeId.href],
+    );
   }
 
-  vote(messageId: Uuid, voterId: URL, option: string): Promise<void> {
-    const poll = this.polls[messageId] ??= {};
+  async *findFollowedBots(followeeId: URL): AsyncIterable<string> {
+    for (const [identifier, data] of this.#data) {
+      if (followeeId.href in data.followees) yield identifier;
+    }
+  }
+
+  vote(
+    identifier: string,
+    messageId: Uuid,
+    voterId: URL,
+    option: string,
+  ): Promise<void> {
+    const poll = this.#bucket(identifier).polls[messageId] ??= {};
     const voters = poll[option] ??= new Set();
     voters.add(voterId.href);
     return Promise.resolve();
   }
 
-  countVoters(messageId: Uuid): Promise<number> {
-    const poll = this.polls[messageId];
+  countVoters(identifier: string, messageId: Uuid): Promise<number> {
+    const poll = this.#data.get(identifier)?.polls[messageId];
     if (poll == null) return Promise.resolve(0);
     let voters = new Set<string>();
     for (const votersSet of globalThis.Object.values(poll)) {
@@ -939,8 +1560,11 @@ export class MemoryRepository implements Repository {
     return Promise.resolve(voters.size);
   }
 
-  countVotes(messageId: Uuid): Promise<Readonly<Record<string, number>>> {
-    const poll = this.polls[messageId];
+  countVotes(
+    identifier: string,
+    messageId: Uuid,
+  ): Promise<Readonly<Record<string, number>>> {
+    const poll = this.#data.get(identifier)?.polls[messageId];
     if (poll == null) return Promise.resolve({});
     const counts: Record<string, number> = {};
     for (const [option, voters] of globalThis.Object.entries(poll)) {
@@ -948,6 +1572,10 @@ export class MemoryRepository implements Repository {
     }
     return Promise.resolve(counts);
   }
+
+  forIdentifier(identifier: string): ActorScopedRepository {
+    return new ActorScopedRepository(this, identifier);
+  }
 }
 
 /**
@@ -956,9 +1584,10 @@ export class MemoryRepository implements Repository {
  * of accesses to the underlying persistent storage, but it increases memory
  * usage. The cache is not persistent and will be lost when the process exits.
  *
- * Note: List operations like `getMessages` and `getFollowers`, and count
- * operations like `countMessages` and `countFollowers` are not cached and
- * always delegate to the underlying repository.
+ * Note: List operations like `getMessages` and `getFollowers`, count
+ * operations like `countMessages` and `countFollowers`, and reverse lookups
+ * like `findFollowedBots` are not cached and always delegate to the
+ * underlying repository.
  * @since 0.3.0
  */
 export class MemoryCachedRepository implements Repository {
@@ -976,182 +1605,272 @@ export class MemoryCachedRepository implements Repository {
     this.cache = cache ?? new MemoryRepository();
   }
 
-  async setKeyPairs(keyPairs: CryptoKeyPair[]): Promise<void> {
-    await this.underlying.setKeyPairs(keyPairs);
-    await this.cache.setKeyPairs(keyPairs);
+  async setKeyPairs(
+    identifier: string,
+    keyPairs: CryptoKeyPair[],
+  ): Promise<void> {
+    await this.underlying.setKeyPairs(identifier, keyPairs);
+    await this.cache.setKeyPairs(identifier, keyPairs);
   }
 
-  async getKeyPairs(): Promise<CryptoKeyPair[] | undefined> {
-    let keyPairs = await this.cache.getKeyPairs();
+  async getKeyPairs(identifier: string): Promise<CryptoKeyPair[] | undefined> {
+    let keyPairs = await this.cache.getKeyPairs(identifier);
     if (keyPairs === undefined) {
-      keyPairs = await this.underlying.getKeyPairs();
-      if (keyPairs !== undefined) await this.cache.setKeyPairs(keyPairs);
+      keyPairs = await this.underlying.getKeyPairs(identifier);
+      if (keyPairs !== undefined) {
+        await this.cache.setKeyPairs(identifier, keyPairs);
+      }
     }
     return keyPairs;
   }
 
-  async addMessage(id: Uuid, activity: Create | Announce): Promise<void> {
-    await this.underlying.addMessage(id, activity);
-    await this.cache.addMessage(id, activity);
+  async addMessage(
+    identifier: string,
+    id: Uuid,
+    activity: Create | Announce,
+  ): Promise<void> {
+    await this.underlying.addMessage(identifier, id, activity);
+    await this.cache.addMessage(identifier, id, activity);
   }
 
   async updateMessage(
+    identifier: string,
     id: Uuid,
     updater: (
       existing: Create | Announce,
     ) => Create | Announce | undefined | Promise<Create | Announce | undefined>,
   ): Promise<boolean> {
     // Apply update to underlying first
-    const updated = await this.underlying.updateMessage(id, updater);
+    const updated = await this.underlying.updateMessage(
+      identifier,
+      id,
+      updater,
+    );
     if (updated) {
       // If successful, fetch the updated message and update the cache
-      const updatedMessage = await this.underlying.getMessage(id);
+      const updatedMessage = await this.underlying.getMessage(identifier, id);
       if (updatedMessage) {
-        await this.cache.addMessage(id, updatedMessage); // Use addMessage which acts like set
+        // Use addMessage which acts like set
+        await this.cache.addMessage(identifier, id, updatedMessage);
       } else {
         // Should not happen if updateMessage returned true, but handle defensively
-        await this.cache.removeMessage(id);
+        await this.cache.removeMessage(identifier, id);
       }
     }
     return updated;
   }
 
-  async removeMessage(id: Uuid): Promise<Create | Announce | undefined> {
-    const removedActivity = await this.underlying.removeMessage(id);
+  async removeMessage(
+    identifier: string,
+    id: Uuid,
+  ): Promise<Create | Announce | undefined> {
+    const removedActivity = await this.underlying.removeMessage(identifier, id);
     if (removedActivity !== undefined) {
-      await this.cache.removeMessage(id);
+      await this.cache.removeMessage(identifier, id);
     }
     return removedActivity;
   }
 
   // getMessages is not cached due to complexity with options
   getMessages(
+    identifier: string,
     options?: RepositoryGetMessagesOptions,
   ): AsyncIterable<Create | Announce> {
-    return this.underlying.getMessages(options);
+    return this.underlying.getMessages(identifier, options);
   }
 
-  async getMessage(id: Uuid): Promise<Create | Announce | undefined> {
-    let message = await this.cache.getMessage(id);
+  async getMessage(
+    identifier: string,
+    id: Uuid,
+  ): Promise<Create | Announce | undefined> {
+    let message = await this.cache.getMessage(identifier, id);
     if (message === undefined) {
-      message = await this.underlying.getMessage(id);
+      message = await this.underlying.getMessage(identifier, id);
       if (message !== undefined) {
-        await this.cache.addMessage(id, message); // Use addMessage which acts like set
+        // Use addMessage which acts like set
+        await this.cache.addMessage(identifier, id, message);
       }
     }
     return message;
   }
 
   // countMessages is not cached
-  countMessages(): Promise<number> {
-    return this.underlying.countMessages();
+  countMessages(identifier: string): Promise<number> {
+    return this.underlying.countMessages(identifier);
   }
 
-  async addFollower(followId: URL, follower: Actor): Promise<void> {
-    await this.underlying.addFollower(followId, follower);
-    await this.cache.addFollower(followId, follower);
+  async addFollower(
+    identifier: string,
+    followId: URL,
+    follower: Actor,
+  ): Promise<void> {
+    await this.underlying.addFollower(identifier, followId, follower);
+    await this.cache.addFollower(identifier, followId, follower);
   }
 
   async removeFollower(
+    identifier: string,
     followId: URL,
     followerId: URL,
   ): Promise<Actor | undefined> {
     const removedFollower = await this.underlying.removeFollower(
+      identifier,
       followId,
       followerId,
     );
     if (removedFollower !== undefined) {
-      await this.cache.removeFollower(followId, followerId);
+      await this.cache.removeFollower(identifier, followId, followerId);
     }
     return removedFollower;
   }
 
-  async hasFollower(followerId: URL): Promise<boolean> {
+  async hasFollower(identifier: string, followerId: URL): Promise<boolean> {
     // Check cache first for potentially faster response
-    if (await this.cache.hasFollower(followerId)) {
+    if (await this.cache.hasFollower(identifier, followerId)) {
       return true;
     }
     // If not in cache, check underlying and update cache if found
-    const exists = await this.underlying.hasFollower(followerId);
+    const exists = await this.underlying.hasFollower(identifier, followerId);
     // Note: We don't automatically add to cache here, as we don't have the Actor object
     // It will be cached if addFollower is called or if getFollowers iterates over it (though getFollowers isn't cached)
     return exists;
   }
 
   // getFollowers is not cached due to complexity with options
-  getFollowers(options?: RepositoryGetFollowersOptions): AsyncIterable<Actor> {
+  getFollowers(
+    identifier: string,
+    options?: RepositoryGetFollowersOptions,
+  ): AsyncIterable<Actor> {
     // We could potentially cache followers as they are iterated,
     // but for simplicity, delegate directly for now.
-    return this.underlying.getFollowers(options);
+    return this.underlying.getFollowers(identifier, options);
   }
 
   // countFollowers is not cached
-  countFollowers(): Promise<number> {
-    return this.underlying.countFollowers();
+  countFollowers(identifier: string): Promise<number> {
+    return this.underlying.countFollowers(identifier);
   }
 
-  async addSentFollow(id: Uuid, follow: Follow): Promise<void> {
-    await this.underlying.addSentFollow(id, follow);
-    await this.cache.addSentFollow(id, follow);
+  async addSentFollow(
+    identifier: string,
+    id: Uuid,
+    follow: Follow,
+  ): Promise<void> {
+    await this.underlying.addSentFollow(identifier, id, follow);
+    await this.cache.addSentFollow(identifier, id, follow);
   }
 
-  async removeSentFollow(id: Uuid): Promise<Follow | undefined> {
-    const removedFollow = await this.underlying.removeSentFollow(id);
+  async removeSentFollow(
+    identifier: string,
+    id: Uuid,
+  ): Promise<Follow | undefined> {
+    const removedFollow = await this.underlying.removeSentFollow(
+      identifier,
+      id,
+    );
     if (removedFollow !== undefined) {
-      await this.cache.removeSentFollow(id);
+      await this.cache.removeSentFollow(identifier, id);
     }
     return removedFollow;
   }
 
-  async getSentFollow(id: Uuid): Promise<Follow | undefined> {
-    let follow = await this.cache.getSentFollow(id);
+  async getSentFollow(
+    identifier: string,
+    id: Uuid,
+  ): Promise<Follow | undefined> {
+    let follow = await this.cache.getSentFollow(identifier, id);
     if (follow === undefined) {
-      follow = await this.underlying.getSentFollow(id);
+      follow = await this.underlying.getSentFollow(identifier, id);
       if (follow !== undefined) {
-        await this.cache.addSentFollow(id, follow);
+        await this.cache.addSentFollow(identifier, id, follow);
       }
     }
     return follow;
   }
 
-  async addFollowee(followeeId: URL, follow: Follow): Promise<void> {
-    await this.underlying.addFollowee(followeeId, follow);
-    await this.cache.addFollowee(followeeId, follow);
+  async addFollowee(
+    identifier: string,
+    followeeId: URL,
+    follow: Follow,
+  ): Promise<void> {
+    await this.underlying.addFollowee(identifier, followeeId, follow);
+    await this.cache.addFollowee(identifier, followeeId, follow);
   }
 
-  async removeFollowee(followeeId: URL): Promise<Follow | undefined> {
-    const removedFollow = await this.underlying.removeFollowee(followeeId);
-    if (removedFollow !== undefined) {
-      await this.cache.removeFollowee(followeeId);
-    }
+  async removeFollowee(
+    identifier: string,
+    followeeId: URL,
+  ): Promise<Follow | undefined> {
+    const removedFollow = await this.underlying.removeFollowee(
+      identifier,
+      followeeId,
+    );
+    // Invalidate the cache even when the underlying repository returned
+    // nothing: a retried removal may have already deleted the record while
+    // the cache still holds it.
+    await this.cache.removeFollowee(identifier, followeeId);
     return removedFollow;
   }
 
-  async getFollowee(followeeId: URL): Promise<Follow | undefined> {
-    let follow = await this.cache.getFollowee(followeeId);
+  async getFollowee(
+    identifier: string,
+    followeeId: URL,
+  ): Promise<Follow | undefined> {
+    let follow = await this.cache.getFollowee(identifier, followeeId);
     if (follow === undefined) {
-      follow = await this.underlying.getFollowee(followeeId);
+      follow = await this.underlying.getFollowee(identifier, followeeId);
       if (follow !== undefined) {
-        await this.cache.addFollowee(followeeId, follow);
+        await this.cache.addFollowee(identifier, followeeId, follow);
       }
     }
     return follow;
   }
 
-  async vote(messageId: Uuid, voterId: URL, option: string): Promise<void> {
-    await this.cache.vote(messageId, voterId, option);
-    await this.underlying.vote(messageId, voterId, option);
+  // findFollowedBots is not cached, since the cache may not have the complete
+  // set of followees
+  findFollowedBots(followeeId: URL): AsyncIterable<string> {
+    return this.underlying.findFollowedBots(followeeId);
   }
 
-  async countVoters(messageId: Uuid): Promise<number> {
-    const voters = await this.cache.countVoters(messageId);
+  async vote(
+    identifier: string,
+    messageId: Uuid,
+    voterId: URL,
+    option: string,
+  ): Promise<void> {
+    await this.cache.vote(identifier, messageId, voterId, option);
+    await this.underlying.vote(identifier, messageId, voterId, option);
+  }
+
+  async countVoters(identifier: string, messageId: Uuid): Promise<number> {
+    const voters = await this.cache.countVoters(identifier, messageId);
     if (voters > 0) return voters;
-    return this.underlying.countVoters(messageId);
+    return this.underlying.countVoters(identifier, messageId);
   }
 
-  async countVotes(messageId: Uuid): Promise<Readonly<Record<string, number>>> {
-    const votes = await this.cache.countVotes(messageId);
+  async countVotes(
+    identifier: string,
+    messageId: Uuid,
+  ): Promise<Readonly<Record<string, number>>> {
+    const votes = await this.cache.countVotes(identifier, messageId);
     if (globalThis.Object.keys(votes).length > 0) return votes;
-    return await this.underlying.countVotes(messageId);
+    return await this.underlying.countVotes(identifier, messageId);
+  }
+
+  forIdentifier(identifier: string): ActorScopedRepository {
+    return new ActorScopedRepository(this, identifier);
+  }
+
+  /**
+   * Migrates data stored by BotKit 0.4 or earlier in the underlying
+   * repository, so that it belongs to the given identifier.  The cache is
+   * not involved: it starts empty and only ever holds values read after
+   * the migration.
+   * @param identifier The identifier of the bot actor that adopts the
+   *                   legacy data.
+   * @since 0.5.0
+   */
+  async migrate(identifier: string): Promise<void> {
+    await this.underlying.migrate?.(identifier);
   }
 }
diff --git a/packages/botkit/src/session-impl.test.ts b/packages/botkit/src/session-impl.test.ts
index e505914..ddc2d8f 100644
--- a/packages/botkit/src/session-impl.test.ts
+++ b/packages/botkit/src/session-impl.test.ts
@@ -61,7 +61,10 @@ test("SessionImpl.follow()", async (t) => {
     assert.deepStrictEqual(activity.actorId, ctx.getActorUri(bot.identifier));
     assert.deepStrictEqual(activity.objectId, actor.id);
     assert.deepStrictEqual(activity.toIds, [actor.id]);
-    const follow = await repository.getSentFollow(parsed.values.id as Uuid);
+    const follow = await repository.getSentFollow(
+      "bot",
+      parsed.values.id as Uuid,
+    );
     assert.ok(follow != null);
     assert.deepStrictEqual(
       await follow.toJsonLd({ format: "compact" }),
@@ -72,6 +75,7 @@ test("SessionImpl.follow()", async (t) => {
   await t.test("follow again", async () => {
     ctx.sentActivities = [];
     await repository.addFollowee(
+      "bot",
       new URL("https://example.com/ap/actor/alice"),
       new Follow({
         id: new URL(
@@ -134,6 +138,7 @@ test("SessionImpl.unfollow()", async (t) => {
 
   await t.test("unfollow", async () => {
     await repository.addFollowee(
+      "bot",
       new URL("https://example.com/ap/actor/alice"),
       new Follow({
         id: new URL(
@@ -163,6 +168,7 @@ test("SessionImpl.unfollow()", async (t) => {
     assert.deepStrictEqual(object.actorId, ctx.getActorUri(bot.identifier));
     assert.deepStrictEqual(
       await repository.getFollowee(
+        "bot",
         new URL("https://example.com/ap/actor/alice"),
       ),
       undefined,
@@ -229,6 +235,7 @@ describe("SessionImpl.follows()", () => {
       preferredUsername: "alice",
     });
     await repository.addFollowee(
+      "bot",
       new URL("https://example.com/ap/actor/alice"),
       new Follow({
         id: new URL(
@@ -788,10 +795,26 @@ test("SessionImpl.getOutbox()", async (t) => {
     }),
     published: Temporal.Instant.from("2025-01-04T00:00:00Z"),
   });
-  await repository.addMessage("01941f29-7c00-7fe8-ab0a-7b593990a3c0", messageA);
-  await repository.addMessage("0194244f-d800-7873-8993-ef71ccd47306", messageB);
-  await repository.addMessage("01942976-3400-7f34-872e-2cbf0f9eeac4", messageC);
-  await repository.addMessage("01942e9c-9000-7480-a553-7a6ce737ce14", messageD);
+  await repository.addMessage(
+    "bot",
+    "01941f29-7c00-7fe8-ab0a-7b593990a3c0",
+    messageA,
+  );
+  await repository.addMessage(
+    "bot",
+    "0194244f-d800-7873-8993-ef71ccd47306",
+    messageB,
+  );
+  await repository.addMessage(
+    "bot",
+    "01942976-3400-7f34-872e-2cbf0f9eeac4",
+    messageC,
+  );
+  await repository.addMessage(
+    "bot",
+    "01942e9c-9000-7480-a553-7a6ce737ce14",
+    messageD,
+  );
 
   await t.test("default", async () => {
     const outbox = session.getOutbox({ order: "oldest" });
diff --git a/packages/botkit/src/session-impl.ts b/packages/botkit/src/session-impl.ts
index c5eb52e..a7dde04 100644
--- a/packages/botkit/src/session-impl.ts
+++ b/packages/botkit/src/session-impl.ts
@@ -123,7 +123,10 @@ export class SessionImpl<TContextData> implements Session<TContextData> {
     }
     const id = uuidv7() as Uuid;
     const follow = new Follow({
-      id: this.context.getObjectUri(Follow, { id }),
+      id: this.context.getObjectUri(Follow, {
+        identifier: this.bot.identifier,
+        id,
+      }),
       actor: this.context.getActorUri(this.bot.identifier),
       object: actor.id,
       to: actor.id,
@@ -309,7 +312,10 @@ export class SessionImpl<TContextData> implements Session<TContextData> {
       endTime = options.poll.endTime;
     }
     const msg = new cls({
-      id: this.context.getObjectUri<MessageClass>(cls, { id }),
+      id: this.context.getObjectUri<MessageClass>(cls, {
+        identifier: this.bot.identifier,
+        id,
+      }),
       contents: options.language == null
         ? [contentHtml]
         : [new LanguageString(contentHtml, options.language), contentHtml],
@@ -336,10 +342,17 @@ export class SessionImpl<TContextData> implements Session<TContextData> {
         ? [PUBLIC_COLLECTION]
         : [],
       published: published.toTemporalInstant(),
-      url: new URL(`/message/${id}`, this.context.origin),
+      url: this.bot.instance.getMessageWebUrl(
+        this.bot,
+        id,
+        this.context.origin,
+      ),
     });
     const activity = new Create({
-      id: this.context.getObjectUri(Create, { id }),
+      id: this.context.getObjectUri(Create, {
+        identifier: this.bot.identifier,
+        id,
+      }),
       actors: msg.attributionIds,
       tos: msg.toIds,
       ccs: msg.ccIds,
diff --git a/packages/botkit/src/session.ts b/packages/botkit/src/session.ts
index 1e63100..9244562 100644
--- a/packages/botkit/src/session.ts
+++ b/packages/botkit/src/session.ts
@@ -22,7 +22,7 @@ import type {
   Question,
 } from "@fedify/vocab";
 import type { Context } from "@fedify/fedify/federation";
-import type { Bot } from "./bot.ts";
+import type { ReadonlyBot } from "./bot.ts";
 import type {
   AuthorizedMessage,
   Message,
@@ -37,9 +37,14 @@ import type { Text } from "./text.ts";
  */
 export interface Session<TContextData> {
   /**
-   * The bot to which the session belongs.
+   * A read-only view of the bot to which the session belongs.  It exposes
+   * the bot's identity and profile (e.g. `identifier`, `username`, `name`)
+   * without allowing event handlers to be reassigned through it.
+   *
+   * Before BotKit 0.5.0, this property was typed as `Bot`; it is now
+   * a {@link ReadonlyBot} so that a session cannot mutate its bot.
    */
-  readonly bot: Bot<TContextData>;
+  readonly bot: ReadonlyBot;
 
   /**
    * The Fedify context of the session.
diff --git a/packages/botkit/src/text.test.ts b/packages/botkit/src/text.test.ts
index f6db9a2..db27095 100644
--- a/packages/botkit/src/text.test.ts
+++ b/packages/botkit/src/text.test.ts
@@ -20,10 +20,12 @@ import {
 } from "@fedify/fedify/federation";
 import { getDocumentLoader } from "@fedify/vocab-runtime";
 import { importJwk } from "@fedify/fedify/sig";
-import { Emoji, Hashtag, Image, Mention, Person } from "@fedify/vocab";
+import { Emoji, Hashtag, Image, Mention, Person, Service } from "@fedify/vocab";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import { BotImpl } from "./bot-impl.ts";
+import { InstanceImpl } from "./instance-impl.ts";
+import { MemoryRepository } from "./repository.ts";
 import type { BotWithVoidContextData } from "./bot.ts";
 import type { CustomEmoji, DeferredCustomEmoji } from "./emoji.ts";
 import type { Session } from "./session.ts";
@@ -122,7 +124,12 @@ const bot: BotWithVoidContextData = {
       ? federation.createContext(new URL(origin))
       : origin;
     return {
-      bot,
+      bot: {
+        identifier: "bot",
+        username: "bot",
+        class: Service,
+        followerPolicy: "accept",
+      },
       context: ctx,
       actorId: ctx.getActorUri(bot.identifier),
       actorHandle: `@bot@${ctx.host}` as const,
@@ -540,6 +547,54 @@ test("hashtag()", async () => {
   assert.deepStrictEqual(t.getCachedObjects(), []);
 });
 
+test("hashtag() on a multi-bot instance", async () => {
+  const instance = new InstanceImpl<void>({
+    kv: new MemoryKvStore(),
+    repository: new MemoryRepository(),
+  });
+  const alpha = instance.createBot("alpha", { username: "alphabot" });
+  const session = alpha.getSession("https://example.com");
+  const t: Text<"inline", void> = hashtag("Fediverse");
+  // On a multi-bot instance the root /tags/ path is not served; hashtag
+  // links must point at the bot-scoped tag pages:
+  assert.deepStrictEqual(
+    (await Array.fromAsync(t.getHtml(session))).join(""),
+    '<a href="https://example.com/@alphabot/tags/fediverse" ' +
+      'class="mention hashtag" rel="tag" target="_blank">' +
+      "#<span>Fediverse</span></a>",
+  );
+  const tags = await Array.fromAsync(t.getTags(session));
+  assert.deepStrictEqual(tags.length, 1);
+  assert.ok(tags[0] instanceof Hashtag);
+  assert.deepStrictEqual(
+    tags[0].href,
+    new URL("https://example.com/@alphabot/tags/fediverse"),
+  );
+});
+
+test("markdown() hashtags on a multi-bot instance", async () => {
+  const instance = new InstanceImpl<void>({
+    kv: new MemoryKvStore(),
+    repository: new MemoryRepository(),
+  });
+  const alpha = instance.createBot("alpha", { username: "alphabot" });
+  const session = alpha.getSession("https://example.com");
+  const t: Text<"block", void> = markdown("I tag #Hashtag.");
+  assert.deepStrictEqual(
+    (await Array.fromAsync(t.getHtml(session))).join(""),
+    '<p>I tag <a  class="mention hashtag" rel="tag" target="_blank" ' +
+      'href="https://example.com/@alphabot/tags/hashtag">' +
+      "#<span>Hashtag</span></a>.</p>\n",
+  );
+  const tags = await Array.fromAsync(t.getTags(session));
+  assert.deepStrictEqual(tags.length, 1);
+  assert.ok(tags[0] instanceof Hashtag);
+  assert.deepStrictEqual(
+    tags[0].href,
+    new URL("https://example.com/@alphabot/tags/hashtag"),
+  );
+});
+
 test("em()", async () => {
   const session = bot.getSession("https://example.com");
   const t: Text<"inline", void> = em("Hello, World");
diff --git a/packages/botkit/src/text.ts b/packages/botkit/src/text.ts
index 6cf46e1..9aadbd8 100644
--- a/packages/botkit/src/text.ts
+++ b/packages/botkit/src/text.ts
@@ -32,6 +32,7 @@ import { encode } from "html-entities";
 import MarkdownIt from "markdown-it";
 import type { DeferredCustomEmoji } from "./emoji.ts";
 import type { Session } from "./session.ts";
+import { SessionImpl } from "./session-impl.ts";
 
 /**
  * A tree structure representing a text with formatting.  It does not only
@@ -410,7 +411,7 @@ export function mention<TContextData>(
       isActor(b) ? b : async (session) => {
         if (session.actorId.href === b.href) return await session.getActor();
         const documentLoader = await session.context.getDocumentLoader(
-          session.bot,
+          { identifier: session.bot.identifier },
         );
         return await session.context.lookupObject(b, { documentLoader });
       },
@@ -422,7 +423,7 @@ export function mention<TContextData>(
       async (session) => {
         if (session.actorHandle === a) return await session.getActor();
         const documentLoader = await session.context.getDocumentLoader(
-          session.bot,
+          { identifier: session.bot.identifier },
         );
         return await session.context.lookupObject(a, { documentLoader });
       },
@@ -446,13 +447,32 @@ export function mention<TContextData>(
     async (session) => {
       if (a.href === session.actorId.href) return await session.getActor();
       const documentLoader = await session.context.getDocumentLoader(
-        session.bot,
+        { identifier: session.bot.identifier },
       );
       return await session.context.lookupObject(a, { documentLoader });
     },
   );
 }
 
+/**
+ * The base URL (without a trailing slash) under which the hashtag pages of
+ * the session's bot live: the origin itself on a single-bot instance, and
+ * the bot's own web path (e.g. `https://host/@username`) on a multi-bot
+ * instance, where the root `/tags/` path is not served.
+ */
+function getHashtagPageBase<TContextData>(
+  session: Session<TContextData>,
+): string {
+  if (session instanceof SessionImpl) {
+    const url = session.bot.instance.getBotWebUrl(
+      session.bot,
+      session.context.origin,
+    );
+    return url.href.replace(/\/+$/, "");
+  }
+  return session.context.origin;
+}
+
 /**
  * A text tree that renders a hashtag.  You normally don't need to
  * instantiate this directly; use the {@link hashtag} function instead.
@@ -472,7 +492,7 @@ export class HashtagText<TContextData> implements Text<"inline", TContextData> {
 
   async *getHtml(session: Session<TContextData>): AsyncIterable<string> {
     yield '<a href="';
-    yield encode(session.context.origin);
+    yield encode(getHashtagPageBase(session));
     yield "/tags/";
     yield encode(encodeURIComponent(this.#tag.toLowerCase()));
     yield '" class="mention hashtag" rel="tag" target="_blank">#<span>';
@@ -483,8 +503,9 @@ export class HashtagText<TContextData> implements Text<"inline", TContextData> {
   async *getTags(session: Session<TContextData>): AsyncIterable<Link | Object> {
     yield new Hashtag({
       href: new URL(
-        `/tags/${encodeURIComponent(this.#tag.toLowerCase())}`,
-        session.context.origin,
+        `${getHashtagPageBase(session)}/tags/${
+          encodeURIComponent(this.#tag.toLowerCase())
+        }`,
       ),
       name: `#${this.#tag.toLowerCase()}`,
     });
@@ -805,6 +826,7 @@ interface MarkdownEnv {
   mentions: string[];
   hashtags: string[];
   origin: string;
+  tagBase: string;
   actors?: Record<string, string | null>;
 }
 
@@ -850,6 +872,7 @@ export class MarkdownText<TContextData> implements Text<"block", TContextData> {
         mentions: [],
         hashtags: [],
         origin: "http://localhost",
+        tagBase: "http://localhost",
       };
       md.render(content, env);
       this.#mentions = env.mentions;
@@ -858,7 +881,7 @@ export class MarkdownText<TContextData> implements Text<"block", TContextData> {
       md.use(hashtagPlugin, {
         link(hashtag: string, env: MarkdownEnv) {
           const tag = hashtag.substring(1).toLowerCase();
-          return new URL(`/tags/${encodeURIComponent(tag)}`, env.origin).href;
+          return `${env.tagBase}/tags/${encodeURIComponent(tag)}`;
         },
         linkAttributes(_hashtag: string, _env: MarkdownEnv) {
           return {
@@ -876,6 +899,7 @@ export class MarkdownText<TContextData> implements Text<"block", TContextData> {
         mentions: [],
         hashtags: [],
         origin: "http://localhost",
+        tagBase: "http://localhost",
       };
       md.render(content, env);
       this.#hashtags = env.hashtags;
@@ -888,7 +912,9 @@ export class MarkdownText<TContextData> implements Text<"block", TContextData> {
   ): Promise<Record<string, Object>> {
     if (this.#mentions == null) return {};
     if (this.#actors != null) return this.#actors;
-    const documentLoader = await session.context.getDocumentLoader(session.bot);
+    const documentLoader = await session.context.getDocumentLoader({
+      identifier: session.bot.identifier,
+    });
     const objects = await Promise.all(
       this.#mentions.map((m) =>
         m === session.actorHandle
@@ -928,6 +954,7 @@ export class MarkdownText<TContextData> implements Text<"block", TContextData> {
       mentions: [],
       hashtags: [],
       origin: session.context.origin,
+      tagBase: getHashtagPageBase(session),
       actors,
     };
     yield this.#markdownIt.render(this.#content, env);
@@ -949,8 +976,7 @@ export class MarkdownText<TContextData> implements Text<"block", TContextData> {
         yield new Hashtag({
           name: `#${tag}`,
           href: new URL(
-            `/tags/${encodeURIComponent(tag)}`,
-            session.context.origin,
+            `${getHashtagPageBase(session)}/tags/${encodeURIComponent(tag)}`,
           ),
         });
       }
diff --git a/packages/botkit/src/uri.test.ts b/packages/botkit/src/uri.test.ts
new file mode 100644
index 0000000..04a71ab
--- /dev/null
+++ b/packages/botkit/src/uri.test.ts
@@ -0,0 +1,165 @@
+// BotKit by Fedify: A framework for creating ActivityPub bots
+// Copyright (C) 2025–2026 Hong Minhee <https://hongminhee.org/>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+import { MemoryKvStore } from "@fedify/fedify/federation";
+import {
+  Announce,
+  Article,
+  ChatMessage,
+  Create,
+  Follow,
+  Note,
+  Question,
+} from "@fedify/vocab";
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { BotImpl } from "./bot-impl.ts";
+import { parseLocalUri, rewriteLegacyObjectPath } from "./uri.ts";
+
+describe("rewriteLegacyObjectPath()", () => {
+  test("rewrites legacy object paths", () => {
+    assert.deepStrictEqual(
+      rewriteLegacyObjectPath(
+        "/ap/follow/03a395a2-353a-4894-afdb-2cab31a7b004",
+        "bot",
+      ),
+      "/ap/actor/bot/follow/03a395a2-353a-4894-afdb-2cab31a7b004",
+    );
+    for (
+      const type of [
+        "follow",
+        "create",
+        "article",
+        "chat-message",
+        "note",
+        "question",
+        "announce",
+      ]
+    ) {
+      assert.deepStrictEqual(
+        rewriteLegacyObjectPath(`/ap/${type}/123`, "my-bot"),
+        `/ap/actor/my-bot/${type}/123`,
+      );
+    }
+  });
+
+  test("percent-encodes the identifier", () => {
+    assert.deepStrictEqual(
+      rewriteLegacyObjectPath("/ap/note/123", "b/t"),
+      "/ap/actor/b%2Ft/note/123",
+    );
+  });
+
+  test("returns null for non-legacy paths", () => {
+    assert.deepStrictEqual(
+      rewriteLegacyObjectPath("/ap/actor/bot", "bot"),
+      null,
+    );
+    assert.deepStrictEqual(
+      rewriteLegacyObjectPath("/ap/actor/bot/note/123", "bot"),
+      null,
+    );
+    assert.deepStrictEqual(
+      rewriteLegacyObjectPath("/ap/emoji/wave", "bot"),
+      null,
+    );
+    assert.deepStrictEqual(rewriteLegacyObjectPath("/ap/inbox", "bot"), null);
+    assert.deepStrictEqual(
+      rewriteLegacyObjectPath("/message/123", "bot"),
+      null,
+    );
+    assert.deepStrictEqual(
+      rewriteLegacyObjectPath("/ap/note/123/extra", "bot"),
+      null,
+    );
+  });
+});
+
+describe("parseLocalUri()", () => {
+  const bot = new BotImpl<void>({
+    kv: new MemoryKvStore(),
+    username: "bot",
+  });
+  const ctx = bot.federation.createContext(new URL("https://example.com/"));
+
+  test("behaves like Context.parseUri() for canonical URIs", () => {
+    const actorUri = new URL("https://example.com/ap/actor/bot");
+    assert.deepStrictEqual(
+      parseLocalUri(ctx, actorUri, "bot"),
+      ctx.parseUri(actorUri),
+    );
+    const noteUri = new URL(
+      "https://example.com/ap/actor/bot/note/01941f29-7c00-7fe8-ab0a-7b593990a3c0",
+    );
+    const parsed = parseLocalUri(ctx, noteUri, "bot");
+    assert.ok(parsed != null);
+    assert.deepStrictEqual(parsed.type, "object");
+    assert.ok(parsed.type === "object");
+    assert.deepStrictEqual(parsed.class, Note);
+    assert.deepStrictEqual(parsed.values, {
+      identifier: "bot",
+      id: "01941f29-7c00-7fe8-ab0a-7b593990a3c0",
+    });
+  });
+
+  test("recognizes legacy object URIs when a legacy identifier is given", () => {
+    const classes = {
+      follow: Follow,
+      create: Create,
+      article: Article,
+      "chat-message": ChatMessage,
+      note: Note,
+      question: Question,
+      announce: Announce,
+    } as const;
+    for (const [type, cls] of Object.entries(classes)) {
+      const legacyUri = new URL(
+        `https://example.com/ap/${type}/01941f29-7c00-7fe8-ab0a-7b593990a3c0`,
+      );
+      const parsed = parseLocalUri(ctx, legacyUri, "bot");
+      assert.ok(parsed != null, `legacy ${type} URI should parse`);
+      assert.deepStrictEqual(parsed.type, "object");
+      assert.ok(parsed.type === "object");
+      assert.deepStrictEqual(parsed.class, cls);
+      assert.deepStrictEqual(parsed.values, {
+        identifier: "bot",
+        id: "01941f29-7c00-7fe8-ab0a-7b593990a3c0",
+      });
+    }
+  });
+
+  test("does not recognize legacy URIs without a legacy identifier", () => {
+    const legacyUri = new URL(
+      "https://example.com/ap/note/01941f29-7c00-7fe8-ab0a-7b593990a3c0",
+    );
+    assert.deepStrictEqual(parseLocalUri(ctx, legacyUri), null);
+  });
+
+  test("returns null for null and foreign URIs", () => {
+    assert.deepStrictEqual(parseLocalUri(ctx, null, "bot"), null);
+    assert.deepStrictEqual(
+      parseLocalUri(
+        ctx,
+        new URL("https://other.example/ap/note/123"),
+        "bot",
+      ),
+      null,
+    );
+    assert.deepStrictEqual(
+      parseLocalUri(ctx, new URL("https://example.com/unrelated"), "bot"),
+      null,
+    );
+  });
+});
diff --git a/packages/botkit/src/uri.ts b/packages/botkit/src/uri.ts
new file mode 100644
index 0000000..54c7f8b
--- /dev/null
+++ b/packages/botkit/src/uri.ts
@@ -0,0 +1,82 @@
+// BotKit by Fedify: A framework for creating ActivityPub bots
+// Copyright (C) 2025–2026 Hong Minhee <https://hongminhee.org/>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+import type { Context } from "@fedify/fedify/federation";
+
+/**
+ * The path pattern of local object URIs generated by BotKit 0.4 and earlier,
+ * which did not carry the owning bot actor identifier.
+ */
+const legacyObjectPathPattern =
+  /^\/ap\/(follow|create|article|chat-message|note|question|announce)\/([^/]+)$/;
+
+/**
+ * Rewrites a local object URI path in the legacy (pre-0.5) format, which did
+ * not carry the owning bot actor identifier, into the canonical format nested
+ * under the actor path.
+ *
+ * For example, `/ap/follow/123` becomes `/ap/actor/bot/follow/123` for the
+ * identifier `bot`.
+ * @param pathname The URL path to rewrite.
+ * @param identifier The identifier of the bot actor that owns the legacy
+ *                   objects.
+ * @returns The rewritten path, or `null` if the path is not in the legacy
+ *          object URI format.
+ * @since 0.5.0
+ */
+export function rewriteLegacyObjectPath(
+  pathname: string,
+  identifier: string,
+): string | null {
+  const match = legacyObjectPathPattern.exec(pathname);
+  if (match == null) return null;
+  return `/ap/actor/${encodeURIComponent(identifier)}/${match[1]}/${match[2]}`;
+}
+
+/**
+ * Parses a URI as a local ActivityPub resource, like
+ * {@link Context.parseUri}, but additionally recognizes local object URIs in
+ * the legacy (pre-0.5) format when a legacy bot actor identifier is
+ * configured.
+ *
+ * Remote servers may have stored object URIs generated by BotKit 0.4 or
+ * earlier and can send them back in later activities (e.g. `Accept`,
+ * `Undo`, `Like`, or replies), so failing to parse them would break
+ * long-lived interactions after an upgrade.  Since legacy URIs carry no
+ * identifier, they can only be attributed to the single bot actor that
+ * predates the upgrade.
+ * @param ctx The Fedify context to parse the URI with.
+ * @param uri The URI to parse.
+ * @param legacyIdentifier The identifier of the bot actor that owns objects
+ *                         with legacy URIs, or `undefined` if the instance
+ *                         has no legacy objects.
+ * @returns The parse result, or `null` if the URI is not a local resource.
+ * @since 0.5.0
+ */
+export function parseLocalUri<TContextData>(
+  ctx: Context<TContextData>,
+  uri: URL | null,
+  legacyIdentifier?: string,
+): ReturnType<Context<TContextData>["parseUri"]> {
+  if (uri == null) return null;
+  const parsed = ctx.parseUri(uri);
+  if (parsed != null) return parsed;
+  if (legacyIdentifier == null) return null;
+  const rewrittenPath = rewriteLegacyObjectPath(uri.pathname, legacyIdentifier);
+  if (rewrittenPath == null) return null;
+  const rewritten = new URL(uri.href);
+  rewritten.pathname = rewrittenPath;
+  return ctx.parseUri(rewritten);
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 7a3c18c..cb6fffe 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -163,7 +163,7 @@ importers:
   packages/botkit-postgres:
     dependencies:
       '@fedify/botkit':
-        specifier: ^0.4.0
+        specifier: workspace:^
         version: link:../botkit
       '@fedify/fedify':
         specifier: ^2.1.2
@@ -188,7 +188,7 @@ importers:
   packages/botkit-sqlite:
     dependencies:
       '@fedify/botkit':
-        specifier: 'workspace:'
+        specifier: workspace:^
         version: link:../botkit
       '@fedify/fedify':
         specifier: 'catalog:'