diff --git a/browser-host/channel-commands.mjs b/browser-host/channel-commands.mjs
index 973f874f1e..1748cce9ca 100644
--- a/browser-host/channel-commands.mjs
+++ b/browser-host/channel-commands.mjs
@@ -22,7 +22,7 @@ export function validChannelCommand(event) {
     if (clientId.length !== 2 || !uuid.test(clientId[1])) return false;
     tags = tags.slice(0, -1);
   }
-  const [h, p] = tags;
+  const [h] = tags;
   if (h?.length !== 2 || h[0] !== "h" || !uuid.test(h[1])) return false;
   if (event.kind === 9007) {
     const expected = ["h", "name", "visibility", "channel_type"];
@@ -85,19 +85,29 @@ export function validChannelCommand(event) {
           String(Number(ttlValue)) === ttlValue))
     );
   }
-  // An invitation may name the participant role, or the read-only guest role
-  // Bestie joins private channels with. It never names a role above member.
-  if (event.kind === 9000)
+  if (event.kind === 9000) {
+    // block/buzz#8575: up to 100 distinct `p` tags. An invitation may name
+    // the participant role, or the read-only guest role Bestie joins private
+    // channels with. Several people may share the Bot role a single agent
+    // enrollment already signs; one agent keeps that exact enrollment shape.
+    // Never an elevation.
+    const role = tags.at(-1)?.[0] === "role" ? tags.at(-1) : undefined;
+    const people = tags.slice(1, role ? -1 : undefined);
     return (
       event.content === "" &&
-      (tags.length === 2 ||
-        (tags.length === 3 &&
-          tags[2].length === 2 &&
-          tags[2][0] === "role" &&
-          (tags[2][1] === "member" || tags[2][1] === "guest"))) &&
-      p?.length === 2 &&
-      p[0] === "p" &&
-      /^[0-9a-f]{64}$/.test(p[1])
+      people.length >= 1 &&
+      people.length <= 100 &&
+      people.every(
+        (tag) =>
+          tag.length === 2 && tag[0] === "p" && /^[0-9a-f]{64}$/.test(tag[1]),
+      ) &&
+      new Set(people.map(([, key]) => key)).size === people.length &&
+      (!role ||
+        (role.length === 2 &&
+          (role[1] === "member" ||
+            role[1] === "guest" ||
+            (role[1] === "bot" && people.length > 1))))
     );
+  }
   return false;
 }
diff --git a/browser-host/channel-commands.test.mjs b/browser-host/channel-commands.test.mjs
index f9f6993a0d..806cd2daa8 100644
--- a/browser-host/channel-commands.test.mjs
+++ b/browser-host/channel-commands.test.mjs
@@ -131,6 +131,37 @@ it("accepts one trailing outbox identifier for invitations and rejects ambiguous
     expect(validChannelCommand(invite(tags))).toBe(false);
 });
 
+it("signs a batch invitation of up to 100 distinct people without elevating roles", () => {
+  const invite = (tags) => ({ kind: 9000, created_at: 1, content: "", tags });
+  const h = ["h", id],
+    client = ["client-id", id];
+  const people = (count) =>
+    Array.from({ length: count }, (_, index) => [
+      "p",
+      index.toString(16).padStart(64, "0"),
+    ]);
+  for (const role of [
+    [],
+    [["role", "member"]],
+    [["role", "guest"]],
+    [["role", "bot"]],
+  ])
+    expect(
+      validChannelCommand(invite([h, ...people(100), ...role, client])),
+    ).toBe(true);
+  for (const tags of [
+    [h, ...people(101)],
+    [h, ...people(2), people(1)[0]],
+    [h, ...people(2), ["role", "admin"]],
+    [h, ...people(2), ["role", "owner"]],
+    [h, ["role", "member"]],
+    [h, people(1)[0], ["role", "bot"]],
+    [h, people(2)[0], ["role", "member"], people(2)[1]],
+    [h, ["p", "a".repeat(64), "admin"], ...people(1)],
+  ])
+    expect(validChannelCommand(invite(tags))).toBe(false);
+});
+
 it("allows bounded ordinary stream creation and rejects malformed TTL", () => {
   const create = {
     kind: 9007,
diff --git a/browser-host/relay-broker-api.test.mjs b/browser-host/relay-broker-api.test.mjs
index 1d833c28c2..706dd7324a 100644
--- a/browser-host/relay-broker-api.test.mjs
+++ b/browser-host/relay-broker-api.test.mjs
@@ -1806,14 +1806,40 @@ test("member and guest additions work without channel creation, while role eleva
     expect(h.publications[2].tags).toEqual(
       expect.arrayContaining([["role", "guest"]]),
     );
-    for (const role of ["owner", "admin"]) {
-      const denied = await h.post("sign", {
+    // block/buzz#8575: one addition may name several people.
+    const people = [
+      ["p", "b".repeat(64)],
+      ["p", "c".repeat(64)],
+    ];
+    for (const role of [
+      [],
+      [["role", "member"]],
+      [["role", "guest"]],
+      [["role", "bot"]],
+    ]) {
+      const batchId = owner.outbox.send({
         kind: 9000,
         content: "",
-        created_at: 1700000000,
-        tags: [...tags, ["role", role]],
+        tags: [...tags, ...people, ...role],
       });
-      expect(denied.status).toBe(400);
+      await vi.waitFor(() =>
+        expect(
+          owner.local.snapshot().find((row) => row.event.id === batchId)
+            ?.delivery,
+        ).toBe("accepted"),
+      );
+    }
+    expect(h.publications).toHaveLength(7);
+    for (const role of ["owner", "admin"]) {
+      for (const named of [tags, [...tags, ...people]]) {
+        const denied = await h.post("sign", {
+          kind: 9000,
+          content: "",
+          created_at: 1700000000,
+          tags: [...named, ["role", role]],
+        });
+        expect(denied.status).toBe(400);
+      }
     }
   } finally {
     owner?.dispose();
diff --git a/docs/solo/sharing.md b/docs/solo/sharing.md
index da0f6725e9..f55e8d1a23 100644
--- a/docs/solo/sharing.md
+++ b/docs/solo/sharing.md
@@ -65,6 +65,15 @@ grant fails, the dialog shows the error and **Retry share**; a retry reads the
 channel again and grants only whoever is still missing. Grants already confirmed
 stay. With no channel selected, **Done** closes without writes.
 
+People added together (a share, a team, mentioned nonmembers or brought agents)
+go in one kind 9000 per role, at most 100 each, and the roster is read once after.
+A relay without batch support adds only the first person an event names, so the
+roster decides who was added; anyone else, or anyone with an earlier addition
+still pending, gets the single addition, which reports their own failure. A batch
+is never resent, and stays in Outbox until everyone it names is in the roster or
+has their own addition; its **Retry** checks each person again. See the
+relay's kind 9000 entry in block/buzz `NOSTR.md`.
+
 The sidebar's Shared mark is status only: it uses the verified current roster and
 cached non-agent evidence for an additional human. Unknown profiles remain
 unclassified; absence of the indicator is **not** a privacy promise. Clicking the
diff --git a/src/bundled/channels/OutboxStatus.test.tsx b/src/bundled/channels/OutboxStatus.test.tsx
index 04c17b89fa..e5f59f188b 100644
--- a/src/bundled/channels/OutboxStatus.test.tsx
+++ b/src/bundled/channels/OutboxStatus.test.tsx
@@ -44,11 +44,13 @@ const invitation = {
 function show(item: OutgoingEvent) {
   const retry = vi.fn();
   const add = vi.fn(async () => {});
+  const acknowledge = vi.fn(async () => {});
   const items = [item];
   const outbox = {
     snapshot: () => items,
     subscribe: () => () => {},
     retry,
+    acknowledge,
     dismiss: vi.fn(),
   } as unknown as Outbox;
   render(
@@ -59,7 +61,7 @@ function show(item: OutgoingEvent) {
     />,
   );
   fireEvent.click(screen.getByText("Outbox · 1 items"));
-  return { retry, add };
+  return { retry, add, acknowledge };
 }
 
 it("does not offer generic retry for guarded invitations from either profile or composer", () => {
@@ -177,6 +179,62 @@ it("retries a guest addition as a guest", async () => {
   );
 });
 
+it("retries a guest batch per person as guests, each as a new addition", async () => {
+  const { add } = show({
+    ...invitation,
+    event: {
+      ...invitation.event,
+      tags: [
+        ["h", "channel"],
+        ["p", "one"],
+        ["p", "two"],
+        ["role", "guest"],
+      ],
+    },
+    recovery: { key: "member-add:batch:operation", value: "1" },
+  });
+  fireEvent.click(screen.getByRole("button", { name: "Retry" }));
+  await waitFor(() =>
+    expect(add.mock.calls).toEqual([
+      ["channel", "one", { role: "guest" }],
+      ["channel", "two", { role: "guest" }],
+    ]),
+  );
+});
+
+it.each(["failed", "accepted"] as const)(
+  "retries a %s batch addition per person, never resending it",
+  async (delivery) => {
+    const { retry, add, acknowledge } = show({
+      ...invitation,
+      delivery,
+      event: {
+        ...invitation.event,
+        tags: [
+          ["h", "channel"],
+          ["p", "one"],
+          ["p", "two"],
+          ["role", "member"],
+        ],
+      },
+      recovery: { key: "member-add:batch:operation", value: "1" },
+    });
+    expect(screen.getByText(/Add 2 people/)).toBeVisible();
+    add.mockImplementation(async (...args: unknown[]) => {
+      if (args[1] === "two") throw new Error("Could not add two");
+    });
+    fireEvent.click(screen.getByRole("button", { name: "Retry" }));
+    expect(await screen.findByText(/Could not add two/)).toBeVisible();
+    expect(add.mock.calls).toEqual([
+      ["channel", "one", {}],
+      ["channel", "two", {}],
+    ]);
+    // Additions settle the batch once everyone is; Retry never clears it.
+    expect(acknowledge).not.toHaveBeenCalled();
+    expect(retry).not.toHaveBeenCalled();
+  },
+);
+
 it.each(
   (["failed", "unknown", "admitted"] as const).flatMap((failure) =>
     [false, true].map((restart) => ({ failure, restart })),
diff --git a/src/bundled/channels/OutboxStatus.tsx b/src/bundled/channels/OutboxStatus.tsx
index ce75595e4e..18cd71354a 100644
--- a/src/bundled/channels/OutboxStatus.tsx
+++ b/src/bundled/channels/OutboxStatus.tsx
@@ -6,6 +6,15 @@ import { RelayTimings } from "./RelayTimings";
 import { PRODUCT_FEEDBACK_KIND } from "../../features/relay/product-feedback";
 import type { Outbox } from "../../features/relay/outbox";
 import type { RelaySession } from "../../features/relay/session";
+import { isBatchAddition } from "../../features/channel-members/members";
+
+/** A batch names everyone its Retry re-adds. */
+function additionLabel(tags: readonly (readonly string[])[]) {
+  const people = tags.filter(([tag]) => tag === "p");
+  return people.length > 1
+    ? `Add ${people.length} people`
+    : `Add agent ${people[0]?.[1]?.slice(0, 12) ?? ""}`;
+}
 
 /** Delivery belongs to the session, including messages from other pages or a previous launch. */
 export function OutboxStatus({
@@ -39,7 +48,7 @@ export function OutboxStatus({
           <li key={item.event.id}>
             <span>
               {item.event.kind === 9000
-                ? `Add agent ${item.event.tags.find(([tag]) => tag === "p")?.[1]?.slice(0, 12) ?? ""}`
+                ? additionLabel(item.event.tags)
                 : item.event.content.slice(0, 100)}{" "}
               ·{" "}
               {
@@ -54,7 +63,10 @@ export function OutboxStatus({
             </span>{" "}
             {!isWorkflowOperation(item.event) &&
               !item.guarded &&
-              (item.delivery === "failed" || item.delivery === "unknown") && (
+              (item.delivery === "failed" ||
+                item.delivery === "unknown" ||
+                // A kept batch still names someone unsettled.
+                (isBatchAddition(item) && item.delivery !== "sending")) && (
                 <Button
                   type="button"
                   onClick={async () => {
@@ -67,23 +79,36 @@ export function OutboxStatus({
                         const channelId = item.event.tags.find(
                           ([tag]) => tag === "h",
                         )?.[1];
-                        const pubkey = item.event.tags.find(
-                          ([tag]) => tag === "p",
-                        )?.[1];
-                        if (!channelId || !pubkey)
+                        const pubkeys = item.event.tags.flatMap(
+                          ([tag, value]) =>
+                            tag === "p" && value ? [value] : [],
+                        );
+                        if (!channelId || !pubkeys.length)
                           throw new Error(
                             "Reopen Members to check this addition.",
                           );
-                        // A stale explicit role must never overwrite a newer admission.
-                        // A guest addition is retried as one, so it can finish
-                        // its own receipt and never sends a writing role.
+                        // A stale explicit role must never overwrite a newer
+                        // admission, so each person is checked again. A guest
+                        // addition is retried as one, so it never sends a
+                        // writing role. A single addition finishes only its own
+                        // receipt. A batch is never resumed, so each person it
+                        // names is added again; it clears once all are settled.
                         const guest = item.event.tags.some(
                           ([tag, value]) => tag === "role" && value === "guest",
                         );
-                        await memberAdditions.add(channelId, pubkey, {
-                          ...(guest ? { role: "guest" } : {}),
-                          retry: true,
-                        });
+                        const batch = isBatchAddition(item);
+                        const results = await Promise.allSettled(
+                          pubkeys.map((pubkey) =>
+                            memberAdditions.add(channelId, pubkey, {
+                              ...(guest ? { role: "guest" as const } : {}),
+                              ...(batch ? {} : { retry: true as const }),
+                            }),
+                          ),
+                        );
+                        const failed = results.find(
+                          (result) => result.status === "rejected",
+                        );
+                        if (failed) throw failed.reason;
                       } else outbox.retry(item.event.id);
                       setError(undefined);
                     } catch (reason) {
diff --git a/src/features/channel-members/members.test.ts b/src/features/channel-members/members.test.ts
index e97368f3a9..1be64c0b99 100644
--- a/src/features/channel-members/members.test.ts
+++ b/src/features/channel-members/members.test.ts
@@ -1,10 +1,14 @@
 import { afterEach, expect, it, vi } from "vitest";
-import { createRelaySession } from "../relay/session";
+import { createRelaySession, type RelaySession } from "../relay/session";
 import { PublishRejected, type OutgoingEvent } from "../relay/outbox";
 import { matchesEvent } from "../relay/projection";
 import { keypair, roster, signed } from "../relay/testing";
 import type { RelayEvent } from "../relay/events";
-import { addChannelMember, canAddMembers } from "./members";
+import {
+  addChannelMember,
+  addChannelMembersAtOnce,
+  canAddMembers,
+} from "./members";
 
 const cleanups: (() => void)[] = [];
 it.each([
@@ -982,6 +986,28 @@ it.each(["member", "admin"])(
     });
   },
 );
+it("leaves a recovered legacy Solo Guest to the single addition, outside any batch", async () => {
+  const t = setup("solo", "public", "guest");
+  await t.ready();
+  await savedNoRoleInvitation(t);
+  t.confirmPerson("guest");
+  await expect(t.managedAdd()).rejects.toThrow(/remove them in People/i);
+  t.restart();
+  await t.ready();
+  // This relay models only the person, so the others' batch leaves them be.
+  t.setApply(false);
+  // Requested in one turn, so the others share a batch.
+  const [guest] = await Promise.allSettled(
+    [t.person.pubkey, keypair().pubkey, keypair().pubkey].map((key) =>
+      t.session.memberAdditions.add(t.id, key),
+    ),
+  );
+  // Counting the Guest as added would hide that they can only read.
+  expect(guest).toMatchObject({ status: "rejected" });
+  expect(String((guest as PromiseRejectedResult).reason)).toMatch(
+    /remove them in People/i,
+  );
+});
 it("reports a recovered Guest and permits a fresh Member invite only after explicit removal", async () => {
   const t = setup("solo", "public", "guest");
   await t.ready();
@@ -1297,3 +1323,312 @@ it.each([false, true])(
     expect(t.records()[0]?.acknowledged).toBe(true);
   },
 );
+
+/** A private channel whose relay applies every `p` a kind:9000 names, or only
+ * the first, as a relay without batch support does. */
+function batchSetup(applyAll = true) {
+  const viewer = keypair(),
+    relay = keypair(),
+    agent = keypair();
+  const id = "33333333-3333-4333-8333-333333333333";
+  let members = [viewer.pubkey];
+  let clock = 1700000000;
+  let records: readonly OutgoingEvent[] = [];
+  const published: RelayEvent[] = [];
+  let onPublish = () => {};
+  let rosterReads = 0;
+  let failRosterRead = 0;
+  let rosterDown = false;
+  const publish = vi.fn(async (event: RelayEvent) => {
+    onPublish();
+    const named = event.tags.flatMap(([tag, value]) =>
+      tag === "p" && value ? [value] : [],
+    );
+    members = [...new Set([...members, ...named.slice(0, applyAll ? 100 : 1)])];
+    clock++;
+    published.push(event);
+  });
+  const owner = createRelaySession(
+    {
+      viewer: viewer.pubkey,
+      relayAuthor: relay.pubkey,
+      media: () => undefined,
+      readAgentLibrary: async () => ({
+        definitions: [],
+        identities: [{ pubkey: agent.pubkey, name: "Agent" }],
+      }),
+      writer: {
+        kinds: [9, 9000, 9007],
+        sign: async (template) => signed(viewer, template),
+        publish: async (event) => {
+          await publish(event);
+        },
+      },
+      query: async (filters) => {
+        if (filters.some((filter) => filter.kinds?.includes(39002)))
+          if (++rosterReads === failRosterRead || rosterDown)
+            throw new Error("Roster unavailable");
+        return [
+          signed(relay, {
+            kind: 39000,
+            content: "",
+            tags: [
+              ["d", id],
+              ["t", "stream"],
+              ["private"],
+              ["join_role", "guest"],
+              ["name", "Design"],
+            ],
+          }),
+          roster(relay, id, members, clock),
+        ].filter((event) =>
+          filters.some((filter) => matchesEvent(event, filter)),
+        );
+      },
+    },
+    {
+      outboxStorage: {
+        load: () => records,
+        save: (next) => {
+          records = structuredClone(next);
+        },
+      },
+    },
+  );
+  cleanups.push(() => owner.dispose());
+  return {
+    session: owner.session,
+    id,
+    agent,
+    published,
+    records: () => records,
+    members: () => members,
+    /** Runs as the relay receives each write, e.g. another owner's admission. */
+    onPublish(run: () => void) {
+      onPublish = run;
+    },
+    /** Fails the relay's nth roster read from now. */
+    failRosterRead(nth: number) {
+      failRosterRead = rosterReads + nth;
+    },
+    /** Fails every roster read until restored. */
+    rosterDown(down: boolean) {
+      rosterDown = down;
+    },
+    admit(key: string) {
+      members = [...members, key];
+      clock++;
+    },
+    async ready() {
+      owner.session.channels.ensureList();
+      await vi.waitFor(() =>
+        expect(owner.session.channels.list().status).toBe("ready"),
+      );
+      await owner.session.agentChoices.refresh();
+    },
+    addAll: (keys: readonly string[]) =>
+      Promise.all(
+        keys.map((key) => owner.session.memberAdditions.add(id, key)),
+      ),
+  };
+}
+const people = (count: number) =>
+  Array.from({ length: count }, () => keypair().pubkey);
+
+it("adds people requested together in one write per role and 100 people", async () => {
+  const t = batchSetup();
+  await t.ready();
+  const humans = people(101);
+  await t.addAll([...humans, t.agent.pubkey]);
+  expect(
+    t.published.map((event) => [
+      event.tags.filter(([tag]) => tag === "p").length,
+      event.tags.find(([tag]) => tag === "role")?.[1],
+    ]),
+  ).toEqual([
+    [100, "member"],
+    [1, "member"],
+    [1, "bot"],
+  ]);
+  expect(t.members()).toEqual(
+    expect.arrayContaining([...humans, t.agent.pubkey]),
+  );
+  expect(t.session.memberAdditions.snapshot()).toEqual([]);
+  expect(t.records().filter((item) => !item.acknowledged)).toEqual([]);
+});
+
+it("adds anyone a relay without batch support missed one at a time", async () => {
+  const t = batchSetup(false);
+  await t.ready();
+  const [first = "", second = "", third = ""] = people(3);
+  await t.addAll([first, second, third]);
+  expect(
+    t.published.map((event) =>
+      event.tags.flatMap(([tag, value]) => (tag === "p" ? [value] : [])),
+    ),
+  ).toEqual([[first, second, third], [second], [third]]);
+  expect(t.members()).toEqual(expect.arrayContaining([first, second, third]));
+  expect(t.session.memberAdditions.snapshot()).toEqual([]);
+});
+
+it("leaves a pending single addition to resume, never batching its person again", async () => {
+  const t = batchSetup();
+  await t.ready();
+  const [earlier = "", fresh = "", other = ""] = people(3);
+  const id = t.session.outbox?.send(
+    {
+      kind: 9000,
+      content: "",
+      tags: [
+        ["h", t.id],
+        ["p", earlier],
+        ["role", "member"],
+      ],
+    },
+    { key: `member-add:${t.id}:${earlier}`, value: "1" },
+  );
+  await vi.waitFor(() => expect(t.published).toHaveLength(1));
+  await t.addAll([earlier, fresh, other]);
+  // The earlier write landed, so it is confirmed rather than sent again.
+  expect(t.published.map((event) => event.id)).toEqual([
+    id,
+    expect.any(String),
+  ]);
+  expect(t.published[1]?.tags.filter(([tag]) => tag === "p")).toEqual([
+    ["p", fresh],
+    ["p", other],
+  ]);
+  expect(t.records().filter((item) => !item.acknowledged)).toEqual([]);
+});
+
+it("reads the roster again before a later write, so it never names someone admitted meanwhile", async () => {
+  const t = batchSetup();
+  await t.ready();
+  const [first = "", second = ""] = people(2);
+  // Another owner admits the agent, at any role, while the people's write is held.
+  t.onPublish(() => {
+    t.onPublish(() => {});
+    t.admit(t.agent.pubkey);
+  });
+  await t.addAll([first, second, t.agent.pubkey]);
+  expect(t.published).toHaveLength(1);
+  expect(
+    t.published[0]?.tags.some(([, value]) => value === t.agent.pubkey),
+  ).toBe(false);
+  expect(t.session.memberAdditions.snapshot()).toEqual([]);
+});
+
+it("adds the rest one at a time when the roster can't be read again between writes", async () => {
+  const t = batchSetup();
+  await t.ready();
+  const [first = "", second = ""] = people(2);
+  // The first read precedes the people's write; the second, before the agent's, fails.
+  t.failRosterRead(2);
+  await t.addAll([first, second, t.agent.pubkey]);
+  expect(
+    t.published.map((event) =>
+      event.tags.filter(([tag]) => tag === "p" || tag === "role"),
+    ),
+  ).toEqual([
+    [
+      ["p", first],
+      ["p", second],
+      ["role", "member"],
+    ],
+    [
+      ["p", t.agent.pubkey],
+      ["role", "bot"],
+    ],
+  ]);
+  expect(t.members()).toContain(t.agent.pubkey);
+  expect(t.session.memberAdditions.snapshot()).toEqual([]);
+});
+
+it("keeps a batch until everyone it names is in the roster or has their own addition", async () => {
+  const t = batchSetup(false);
+  await t.ready();
+  const [first = "", second = "", third = ""] = people(3);
+  // The relay adds only the first person; then no roster read succeeds, so
+  // nobody else gets a receipt of their own.
+  t.onPublish(() => {
+    t.onPublish(() => {});
+    t.rosterDown(true);
+  });
+  const failed = await Promise.allSettled([
+    t.session.memberAdditions.add(t.id, first),
+    t.session.memberAdditions.add(t.id, second),
+    t.session.memberAdditions.add(t.id, third),
+  ]);
+  expect(failed.every((result) => result.status === "rejected")).toBe(true);
+  expect(t.published).toHaveLength(1);
+  // The saved batch, which a restart restores, is everyone's only record.
+  const [batch] = t.records().filter((item) => !item.acknowledged);
+  expect(batch?.recovery?.key).toMatch(/^member-add:batch:/);
+  expect(batch?.event.id).toBe(t.published[0]?.id);
+  t.rosterDown(false);
+  await t.addAll([first, second, third]);
+  expect(t.members()).toEqual(expect.arrayContaining([first, second, third]));
+  expect(t.records().filter((item) => !item.acknowledged)).toEqual([]);
+});
+
+it("reads the roster again after a write that couldn't be sent", async () => {
+  const t = batchSetup();
+  await t.ready();
+  const [first = "", second = ""] = people(2);
+  const outbox = t.session.outbox;
+  if (!outbox) throw new Error("Outbox unavailable");
+  // Another owner admits the agent while the people's write fails to send.
+  const send = vi.fn<typeof outbox.send>(() => {
+    t.admit(t.agent.pubkey);
+    throw new Error("Outbox storage is full");
+  });
+  const session = Object.create(t.session, {
+    outbox: { value: Object.create(outbox, { send: { value: send } }) },
+  }) as RelaySession;
+  const added = await addChannelMembersAtOnce(
+    session,
+    t.id,
+    [first, second, t.agent.pubkey],
+    new Map(),
+    new AbortController().signal,
+  );
+  // The roster read before the agent's write omits it, so nothing else is sent.
+  expect(send).toHaveBeenCalledOnce();
+  expect(added.size).toBe(0);
+});
+
+it("leaves out someone archived while the roster is read", async () => {
+  const t = batchSetup();
+  await t.ready();
+  const [first = "", second = "", archived = ""] = people(3);
+  let hidden: readonly string[] = [];
+  const channelWrites = t.session.channelWrites;
+  const session = Object.create(t.session, {
+    archives: {
+      value: { ...t.session.archives, snapshot: () => ({ archived: hidden }) },
+    },
+    channelWrites: {
+      value: Object.create(channelWrites, {
+        refreshMembership: {
+          value: async (id: string) => {
+            const roster = await channelWrites.refreshMembership(id);
+            hidden = [archived];
+            return roster;
+          },
+        },
+      }),
+    },
+  }) as RelaySession;
+  await addChannelMembersAtOnce(
+    session,
+    t.id,
+    [first, second, archived],
+    new Map(),
+    new AbortController().signal,
+  );
+  expect(
+    t.published.map((event) =>
+      event.tags.flatMap(([tag, value]) => (tag === "p" ? [value] : [])),
+    ),
+  ).toEqual([[first, second]]);
+});
diff --git a/src/features/channel-members/members.ts b/src/features/channel-members/members.ts
index b6a950826a..0292ffc6dd 100644
--- a/src/features/channel-members/members.ts
+++ b/src/features/channel-members/members.ts
@@ -1,7 +1,7 @@
 import { archiveHides } from "../relay/identity-archives";
 import type { RelaySession } from "../relay/session";
 import type { ChannelSummary } from "../relay/contracts";
-import type { LocalEvents } from "../relay/outbox";
+import type { LocalEvents, OutgoingEvent } from "../relay/outbox";
 import type { RelayEvent } from "../relay/events";
 
 const keyPattern = /^[0-9a-f]{64}$/;
@@ -47,6 +47,39 @@ export function canShareSoloChat(
   );
 }
 
+const channelOf = (session: RelaySession, channelId: string) =>
+  session.channels.list().channels.find((item) => item.id === channelId) ??
+  session.channels.get?.(channelId);
+
+const knownAgent = (session: RelaySession, pubkey: string) =>
+  session.agentChoices
+    .snapshot()
+    .identities.some((agent) => agent.pubkey === pubkey) ||
+  !!session.profiles.snapshot().get(pubkey)?.isAgent;
+
+/** An explicit Guest stays one; agents join as Bot. Solo sharing and
+ * private-channel invitations grant participation explicitly, independently
+ * of the admission default for public visitors. */
+function additionRole(
+  session: RelaySession,
+  channelId: string,
+  pubkey: string,
+  soloParticipant: boolean,
+  intent?: MemberAdditionIntent,
+) {
+  const current = channelOf(session, channelId);
+  return intent?.role
+    ? intent.role
+    : knownAgent(session, pubkey)
+      ? "bot"
+      : soloParticipant ||
+          (current?.visibility === "private" &&
+            (current.channelType === "stream" ||
+              current.channelType === "forum"))
+        ? "member"
+        : undefined;
+}
+
 /** Reuse the outbox's durable operation on retry, including an unknown result. */
 function waitForAddition(outbox: LocalEvents, id: string, signal: AbortSignal) {
   return new Promise<void>((resolve, reject) => {
@@ -81,6 +114,11 @@ function waitForAddition(outbox: LocalEvents, id: string, signal: AbortSignal) {
   });
 }
 
+const batchPrefix = "member-add:batch:";
+/** A batch addition is settled by the roster read after it, never resumed. */
+export const isBatchAddition = (item: OutgoingEvent) =>
+  !!item.recovery?.key.startsWith(batchPrefix);
+
 export type MemberAdditionIntent = {
   id?: string;
   confirmed?: boolean;
@@ -91,8 +129,20 @@ export type MemberAdditionIntent = {
   retry?: true;
 };
 
-/** Explicit single-person intent. Membership truth and pending writes stay session-owned. */
+/** Explicit single-person intent. Membership truth and pending writes stay
+ * session-owned. Whatever the outcome, settles the batches it may complete. */
 export async function addChannelMember(
+  ...args: Parameters<typeof addOneMember>
+) {
+  const [session, channelId] = args;
+  try {
+    await addOneMember(...args);
+  } finally {
+    await settleBatchAdditions(session, channelId);
+  }
+}
+
+async function addOneMember(
   session: RelaySession,
   channelId: string,
   pubkey: string,
@@ -106,9 +156,7 @@ export async function addChannelMember(
 ): Promise<void> {
   if (!keyPattern.test(pubkey))
     throw new Error("Choose a valid person or agent.");
-  const channel = () =>
-    session.channels.list().channels.find((item) => item.id === channelId) ??
-    session.channels.get?.(channelId);
+  const channel = () => channelOf(session, channelId);
   const checkAccess = () => {
     signal.throwIfAborted();
     if (
@@ -146,16 +194,21 @@ export async function addChannelMember(
   const saved = journal.snapshot();
   const pending = fresh
     ? undefined
-    : (saved.find(({ event, acknowledged }) =>
+    : (saved.find((item) =>
         intent.id
-          ? event.id === intent.id
-          : !acknowledged && matchesTarget(event),
+          ? item.event.id === intent.id
+          : !item.acknowledged &&
+            !isBatchAddition(item) &&
+            matchesTarget(item.event),
       ) ??
       // Keep a resolved legacy Guest outcome actionable after restart.
       (soloParticipant && channel()?.members?.includes(pubkey)
         ? saved.find(
-            ({ event, acknowledged }) =>
-              acknowledged && matchesTarget(event) && noRole(event),
+            (item) =>
+              item.acknowledged &&
+              !isBatchAddition(item) &&
+              matchesTarget(item.event) &&
+              noRole(item.event),
           )
         : undefined));
   // A saved addition finishes only with the role this one asks for.
@@ -180,10 +233,7 @@ export async function addChannelMember(
       soloParticipant &&
       !allowSoloAgents &&
       !recoveringSoloAgent &&
-      (session.agentChoices
-        .snapshot()
-        .identities.some((agent) => agent.pubkey === pubkey) ||
-        session.profiles.snapshot().get(pubkey)?.isAgent)
+      knownAgent(session, pubkey)
     )
       throw new Error(
         "Add agents by tagging them in the chat composer instead.",
@@ -262,7 +312,7 @@ export async function addChannelMember(
       if (intent.retry && recorded && !channel()?.members?.includes(pubkey))
         return;
       // A joined target still needs role reconciliation; never overwrite a Guest.
-      return addChannelMember(
+      return addOneMember(
         session,
         channelId,
         pubkey,
@@ -324,24 +374,13 @@ export async function addChannelMember(
   return confirmAddition(id);
 
   function invitation() {
-    const isAgent =
-      session.agentChoices
-        .snapshot()
-        .identities.some((agent) => agent.pubkey === pubkey) ||
-      session.profiles.snapshot().get(pubkey)?.isAgent;
-    const current = channel();
-    // Solo sharing and private-channel invitations grant participation explicitly,
-    // independently of the admission default for public visitors.
-    const role = intent.role
-      ? intent.role
-      : isAgent
-        ? "bot"
-        : soloParticipant ||
-            (current?.visibility === "private" &&
-              (current.channelType === "stream" ||
-                current.channelType === "forum"))
-          ? "member"
-          : undefined;
+    const role = additionRole(
+      session,
+      channelId,
+      pubkey,
+      soloParticipant,
+      intent,
+    );
     return {
       kind: 9000,
       content: "",
@@ -353,3 +392,197 @@ export async function addChannelMember(
     };
   }
 }
+
+/** A batch is the only durable record of the people it names until each is
+ * in the roster or has their own addition pending, so only then is it
+ * acknowledged. Batches still sending are left to their own sender. */
+export async function settleBatchAdditions(
+  session: RelaySession,
+  channelId: string,
+) {
+  const outbox = session.outbox;
+  if (!outbox) return;
+  const items = outbox
+    .snapshot()
+    .filter(
+      (item) =>
+        !item.acknowledged &&
+        item.event.kind === 9000 &&
+        item.event.tags.some(
+          ([tag, value]) => tag === "h" && value === channelId,
+        ),
+    );
+  const named = (item: OutgoingEvent) =>
+    item.event.tags.flatMap(([tag, value]) => (tag === "p" ? [value] : []));
+  const covered = new Set([
+    ...(channelOf(session, channelId)?.members ?? []),
+    ...items.filter((item) => !isBatchAddition(item)).flatMap(named),
+  ]);
+  for (const item of items)
+    if (
+      isBatchAddition(item) &&
+      item.delivery !== "sending" &&
+      named(item).every((key) => covered.has(key))
+    )
+      await outbox.acknowledge(item.event.id).catch(() => {});
+}
+
+/** Most people one kind:9000 may name; see the relay's put-user handler. */
+const batchLimit = 100;
+
+/**
+ * Adds people missing from a channel with one kind:9000 per role and at most
+ * 100 people, then reads the roster once. Returns everyone it shows, including
+ * people already there. A relay without batch support adds only the first
+ * person each event names. Best effort: only an abort or `beforeDispatch`
+ * throws. Everyone not returned is left to `addChannelMember`, which also says
+ * why they failed, as is anyone with an earlier single addition pending, so a
+ * stale role is never resent. A batch is never resumed and never blocks one;
+ * it stays in Outbox until everyone it names is settled.
+ */
+export async function addChannelMembersAtOnce(
+  session: RelaySession,
+  channelId: string,
+  people: readonly string[],
+  intents: ReadonlyMap<string, MemberAdditionIntent>,
+  signal: AbortSignal,
+  soloParticipant = false,
+  beforeDispatch?: () => void,
+  /** Receipts the single addition reads, including resolved ones. */
+  receipts?: LocalEvents,
+): Promise<ReadonlySet<string>> {
+  const confirmed = new Set<string>();
+  const outbox = session.outbox;
+  if (people.length < 2 || !outbox) return confirmed;
+  const allowed = () =>
+    soloParticipant
+      ? canShareSoloChat(session, channelOf(session, channelId))
+      : canAddMembers(session, channelOf(session, channelId));
+  const attempt = async <T>(work: () => T | Promise<T>) => {
+    try {
+      return await work();
+    } catch {
+      signal.throwIfAborted();
+      return undefined;
+    }
+  };
+  // Restored receipts count, so read them only once the outbox has loaded.
+  const loaded = await attempt(async () => {
+    await outbox.ready();
+    return true;
+  });
+  if (!loaded) return confirmed;
+  const singles = (receipts ?? outbox)
+    .snapshot()
+    .filter(
+      (item) =>
+        !isBatchAddition(item) &&
+        item.event.kind === 9000 &&
+        item.event.tags.some(
+          ([tag, value]) => tag === "h" && value === channelId,
+        ),
+    );
+  const named = (items: readonly OutgoingEvent[]) =>
+    new Set(
+      items.flatMap(({ event }) =>
+        event.tags.flatMap(([tag, value]) => (tag === "p" ? [value] : [])),
+      ),
+    );
+  const pending = named(singles.filter((item) => !item.acknowledged));
+  // A Solo chat's resolved no-role invitation may have granted Guest, which
+  // only the single addition reconciles and reports.
+  const legacy = soloParticipant
+    ? named(
+        singles.filter(
+          (item) =>
+            item.acknowledged &&
+            !item.event.tags.some(([tag]) => tag === "role"),
+        ),
+      )
+    : new Set<string>();
+  // Anyone with a single addition pending, or whom one would refuse, stays
+  // with it: it alone may resume that write, and it reports why. Retry only
+  // finishes an existing receipt, so it never joins a batch.
+  const eligible = people.filter(
+    (key) =>
+      keyPattern.test(key) &&
+      !intents.get(key)?.id &&
+      !intents.get(key)?.retry &&
+      !pending.has(key) &&
+      !legacy.has(key) &&
+      !archiveHides(session.archives, key, session.viewer) &&
+      // A Solo chat's agents keep their own receipts, so a recovering share
+      // can finish its exact Bot grant.
+      !(soloParticipant && knownAgent(session, key)),
+  );
+  if (eligible.length < 2) return confirmed;
+  const before = allowed()
+    ? await attempt(() => session.channelWrites.refreshMembership(channelId))
+    : undefined;
+  signal.throwIfAborted();
+  if (!before || !allowed()) return confirmed;
+  const groups = new Map<string | undefined, string[]>();
+  for (const key of eligible)
+    if (!before.members?.includes(key)) {
+      const role = additionRole(
+        session,
+        channelId,
+        key,
+        soloParticipant,
+        intents.get(key),
+      );
+      groups.set(role, [...(groups.get(role) ?? []), key]);
+    }
+  let sent = false;
+  try {
+    let roster: ChannelSummary | undefined = before;
+    let dispatched = false;
+    // One missing person gains nothing from a batch; the single addition sends it.
+    if ([...groups.values()].flat().length > 1)
+      for (const [role, keys] of groups)
+        for (let start = 0; start < keys.length; start += batchLimit) {
+          // Each later write reads the roster again, so it never names someone
+          // admitted meanwhile, whose role an explicit one would overwrite.
+          if (dispatched)
+            roster = await attempt(() =>
+              session.channelWrites.refreshMembership(channelId),
+            );
+          if (!roster || !allowed()) break;
+          const recipients = keys.slice(start, start + batchLimit).filter(
+            (key) =>
+              !roster?.members?.includes(key) &&
+              // Archives may refresh during any read, as the single addition rechecks.
+              !archiveHides(session.archives, key, session.viewer),
+          );
+          if (!recipients.length) continue;
+          dispatched = true;
+          beforeDispatch?.();
+          const id = await attempt(() =>
+            outbox.send(
+              {
+                kind: 9000,
+                content: "",
+                tags: [
+                  ["h", channelId],
+                  ...recipients.map((key) => ["p", key]),
+                  ...(role ? [["role", role]] : []),
+                ],
+              },
+              { key: `${batchPrefix}${crypto.randomUUID()}`, value: "1" },
+            ),
+          );
+          if (!id) continue;
+          sent = true;
+          // A refusal or unknown result still leaves the roster to decide.
+          await attempt(() => waitForAddition(outbox, id, signal));
+        }
+    const after = sent
+      ? await attempt(() => session.channelWrites.refreshMembership(channelId))
+      : before;
+    for (const key of eligible)
+      if (after?.members?.includes(key)) confirmed.add(key);
+    return confirmed;
+  } finally {
+    await settleBatchAdditions(session, channelId);
+  }
+}
diff --git a/src/features/channel-members/operations.test.ts b/src/features/channel-members/operations.test.ts
index ff914e0b3f..aa0cfcf201 100644
--- a/src/features/channel-members/operations.test.ts
+++ b/src/features/channel-members/operations.test.ts
@@ -113,3 +113,59 @@ it("keeps Retry separate from a concurrent explicit Add and clears its flag afte
   await owner.add("channel", "person");
   expect(add).toHaveBeenCalledTimes(2);
 });
+
+it("batches additions to a channel requested in the same turn and adds the rest singly", async () => {
+  const add = vi.fn(async (_channel: string, _key: string) => {});
+  const addAtOnce = vi.fn(async () => new Set(["one", "two"]));
+  const owner = createMemberAdditions(
+    new AbortController().signal,
+    add,
+    undefined,
+    addAtOnce,
+  );
+  await Promise.all(
+    ["one", "two", "three"].map((key) => owner.add("channel", key)),
+  );
+  await owner.add("other", "four");
+  expect(addAtOnce).toHaveBeenCalledExactlyOnceWith(
+    "channel",
+    ["one", "two", "three"],
+    expect.any(Map),
+  );
+  // Whoever the roster didn't show, and a lone request, get a single addition.
+  expect(add.mock.calls.map(([channel, key]) => [channel, key])).toEqual([
+    ["channel", "three"],
+    ["other", "four"],
+  ]);
+  expect(owner.snapshot()).toEqual([]);
+});
+
+it("never batches a Retry, which may only finish its own receipt", async () => {
+  const add = vi.fn(async () => {});
+  const addAtOnce = vi.fn(async () => new Set(["one", "two"]));
+  const owner = createMemberAdditions(
+    new AbortController().signal,
+    add,
+    undefined,
+    addAtOnce,
+  );
+  await Promise.all(
+    ["one", "two"].map((key) => owner.add("channel", key, { retry: true })),
+  );
+  expect(addAtOnce).not.toHaveBeenCalled();
+  expect(add).toHaveBeenCalledTimes(2);
+});
+
+it("adds everyone singly when the batch fails", async () => {
+  const add = vi.fn(async () => {});
+  const owner = createMemberAdditions(
+    new AbortController().signal,
+    add,
+    undefined,
+    async () => {
+      throw new Error("Roster unavailable");
+    },
+  );
+  await Promise.all(["one", "two"].map((key) => owner.add("channel", key)));
+  expect(add).toHaveBeenCalledTimes(2);
+});
diff --git a/src/features/channel-members/operations.ts b/src/features/channel-members/operations.ts
index ec0a8295d0..bf4a09a513 100644
--- a/src/features/channel-members/operations.ts
+++ b/src/features/channel-members/operations.ts
@@ -21,11 +21,45 @@ export function createMemberAdditions(
     intent: MemberAdditionIntent,
   ) => Promise<void>,
   receipts?: LocalEvents,
+  /** Adds several people at once; returns who the roster then shows. */
+  addAtOnce?: (
+    channelId: string,
+    pubkeys: readonly string[],
+    intents: ReadonlyMap<string, MemberAdditionIntent>,
+  ) => Promise<ReadonlySet<string>>,
 ) {
   let snapshot: readonly Addition[] = [];
   const listeners = new Set<() => void>();
   const pending = new Map<string, Promise<void>>();
   const intents = new Map<string, MemberAdditionIntent>();
+  /** Additions to a channel requested in the same turn share one batch. */
+  const batches = new Map<
+    string,
+    {
+      people: Map<string, MemberAdditionIntent>;
+      shown: Promise<ReadonlySet<string>>;
+    }
+  >();
+  function batch(
+    channelId: string,
+    pubkey: string,
+    intent: MemberAdditionIntent,
+  ) {
+    let current = batches.get(channelId);
+    if (!current) {
+      const people = new Map<string, MemberAdditionIntent>();
+      const shown = Promise.resolve().then(() => {
+        batches.delete(channelId);
+        return people.size > 1 && addAtOnce
+          ? addAtOnce(channelId, [...people.keys()], people)
+          : new Set<string>();
+      });
+      current = { people, shown };
+      batches.set(channelId, current);
+    }
+    current.people.set(pubkey, intent);
+    return current.shown;
+  }
   const stopReceipts = trackMemberAdditionReceipts(receipts, () =>
     intents.values(),
   );
@@ -83,6 +117,11 @@ export function createMemberAdditions(
       if (options.retry) intent.retry = true;
       else delete intent.retry;
       let confirmed = previous?.confirmed ?? false;
+      // Retry only finishes an existing receipt, so it never joins a batch.
+      const shown =
+        confirmed || options.retry || !addAtOnce
+          ? undefined
+          : batch(channelId, pubkey, intent);
       const update = (item?: Addition) => {
         if (!signal.aborted)
           publish([
@@ -94,7 +133,9 @@ export function createMemberAdditions(
         .then(async () => {
           signal.throwIfAborted();
           if (!confirmed) {
-            await add(channelId, pubkey, intent);
+            if ((await shown?.catch(() => undefined))?.has(pubkey))
+              intent.confirmed = true;
+            else await add(channelId, pubkey, intent);
             confirmed = true;
           }
           signal.throwIfAborted();
diff --git a/src/features/messages/MessageComposer.test.tsx b/src/features/messages/MessageComposer.test.tsx
index d73478f6db..9429703bf7 100644
--- a/src/features/messages/MessageComposer.test.tsx
+++ b/src/features/messages/MessageComposer.test.tsx
@@ -8228,6 +8228,37 @@ it("Enter on a deliberately focused Invite adds a nonmember before sending", asy
   expect(h.messages.send.mock.calls[0]?.[2]).toEqual([first.pubkey]);
 });
 
+it("invites mentioned nonmembers together so they share one addition", async () => {
+  const h = mount();
+  const held = deferred<void>();
+  const add = vi.fn(() => held.promise);
+  const list = {
+    status: "ready",
+    channels: [
+      { id: "channel", channelType: "stream", members: ["d".repeat(64)] },
+    ],
+  };
+  Object.assign(h.session, {
+    viewer: "d".repeat(64),
+    channels: { list: () => list, subscribeList: () => () => {} },
+    memberAdditions: { add },
+  });
+  act(() => {
+    h.commands().insertMention(first);
+    h.commands().insertMention(second);
+  });
+  fireEvent.submit(screen.getByRole("form"));
+  fireEvent.click(await screen.findByRole("button", { name: "Invite" }));
+  // Both are requested before either finishes.
+  await waitFor(() => expect(add).toHaveBeenCalledTimes(2));
+  expect(add.mock.calls).toEqual([
+    ["channel", first.pubkey],
+    ["channel", second.pubkey],
+  ]);
+  held.resolve();
+  await waitFor(() => expect(h.messages.send).toHaveBeenCalledOnce());
+});
+
 it.each([
   ["", false],
   [", taking it out of its archive here after a Remove", true],
@@ -8313,6 +8344,66 @@ it.each([
   },
 );
 
+it("brings several agents in, then adds them together", async () => {
+  const calls: string[] = [];
+  const join = vi.fn(async (key: string) => {
+    calls.push(`join ${key}`);
+    return { agent: {} as never, notes: [] };
+  });
+  const snapshot = { agents: [] };
+  const types: never[] = [];
+  const agents = {
+    snapshot: () => snapshot,
+    subscribe: () => () => {},
+    find: () => undefined,
+    types: () => types,
+    joinable: () =>
+      [first, second].map((person, index) => ({
+        key: person.pubkey,
+        pubkey: person.pubkey,
+        name: ["Honey", "Pollen"][index],
+        relay: "wss://oss.example.com",
+      })),
+    join,
+  } as unknown as Agents;
+  const h = mount({}, undefined, undefined, agents);
+  const held = deferred<void>();
+  const add = vi.fn((_channel: string, key: string) => {
+    calls.push(`add ${key}`);
+    return held.promise;
+  });
+  const list = {
+    status: "ready",
+    channels: [
+      { id: "channel", channelType: "stream", members: ["d".repeat(64)] },
+    ],
+  };
+  Object.assign(h.session, {
+    viewer: "d".repeat(64),
+    scope: `https://relay.example.test:${"d".repeat(64)}`,
+    channels: { list: () => list, subscribeList: () => () => {} },
+    memberAdditions: { add },
+  });
+  act(() => {
+    h.commands().insertMention(first);
+    h.commands().insertMention(second);
+  });
+  fireEvent.submit(screen.getByRole("form"));
+  fireEvent.click(
+    await screen.findByRole("button", { name: "Bring them here" }),
+  );
+  // Both are requested before either finishes, after every join.
+  await waitFor(() => expect(add).toHaveBeenCalledTimes(2));
+  expect(calls).toEqual([
+    `join ${first.pubkey}`,
+    `join ${second.pubkey}`,
+    `add ${first.pubkey}`,
+    `add ${second.pubkey}`,
+  ]);
+  held.resolve();
+  await waitFor(() => expect(h.messages.send).toHaveBeenCalledOnce());
+});
+
 it.each(["close", "escape", "enter"])(
   "%s preserves the captured draft and returns focus without adding or sending",
   async (action) => {
diff --git a/src/features/messages/useBringAgents.tsx b/src/features/messages/useBringAgents.tsx
index 80218982bb..758ce64947 100644
--- a/src/features/messages/useBringAgents.tsx
+++ b/src/features/messages/useBringAgents.tsx
@@ -68,13 +68,23 @@ export function useBringAgents(
             notes.push(...(await agents.join(agent.key)).notes);
           joined.add(agent.pubkey);
         }
-        if (canAdd && !added.has(agent.pubkey)) {
-          check();
-          await session.memberAdditions.add(channelId, agent.pubkey);
-          added.add(agent.pubkey);
-        }
       }
       check();
+      // Requested together, so they go to the relay together.
+      const results = await Promise.allSettled(
+        canAdd
+          ? request.agents
+              .filter((agent) => !added.has(agent.pubkey))
+              .map((agent) =>
+                session.memberAdditions
+                  .add(channelId, agent.pubkey)
+                  .then(() => added.add(agent.pubkey)),
+              )
+          : [],
+      );
+      const failed = results.find((result) => result.status === "rejected");
+      if (failed) throw failed.reason;
+      check();
       if (notes.length) setPending({ ...request, busy: false, reviewed: true });
       else request.finish([...added]);
     } catch (reason) {
diff --git a/src/features/messages/useNonmemberMentions.tsx b/src/features/messages/useNonmemberMentions.tsx
index 22b1f66ac3..9e0846cc0a 100644
--- a/src/features/messages/useNonmemberMentions.tsx
+++ b/src/features/messages/useNonmemberMentions.tsx
@@ -37,10 +37,16 @@ export function useNonmemberMentions(
     };
     setPending({ ...request, busy: true });
     try {
-      for (const person of request.people) {
-        check();
-        await session.memberAdditions.add(channelId, person.pubkey);
-      }
+      check();
+      // Requested together, so they go to the relay together.
+      const failed = (
+        await Promise.allSettled(
+          request.people.map((person) =>
+            session.memberAdditions.add(channelId, person.pubkey),
+          ),
+        )
+      ).find((result) => result.status === "rejected");
+      if (failed) throw failed.reason;
       check();
       request.finish([]);
     } catch (reason) {
diff --git a/src/features/relay/channel-writes.ts b/src/features/relay/channel-writes.ts
index 2223d2de67..9207199fcd 100644
--- a/src/features/relay/channel-writes.ts
+++ b/src/features/relay/channel-writes.ts
@@ -3,6 +3,7 @@ import { exactLifecycleTag } from "./channel-lifecycle-protocol";
 import { channelIdentityUnsupported, channelLabelTags } from "./channel-labels";
 import { SOLO_NAMED_LABEL, SOLO_LABEL } from "../solo/labels";
 import type { Outbox } from "./outbox";
+import { isBatchAddition } from "../channel-members/members";
 import { withdraw } from "./withdraw";
 import type { ChannelQueries, ChannelSummary } from "./contracts";
 import type { RelayReader } from "./reader";
@@ -494,6 +495,7 @@ export function createChannelWrites(
         return (
           item.event.kind === 9000 &&
           !item.acknowledged &&
+          !isBatchAddition(item) &&
           !["accepted", "seen"].includes(item.delivery) &&
           item.event.tags.some(
             ([name, value]) => name === "h" && value === id,
diff --git a/src/features/relay/session.ts b/src/features/relay/session.ts
index 8ef96810b2..ebd8b782e2 100644
--- a/src/features/relay/session.ts
+++ b/src/features/relay/session.ts
@@ -3,7 +3,10 @@ import type { LocalAgentSource } from "../agents/local-activity";
 import { createSoloPreferences, soloGroups } from "./solo-preferences";
 import { npubEncode } from "nostr-tools/nip19";
 import { createMemberAdditions } from "../channel-members/operations";
-import { addChannelMember } from "../channel-members/members";
+import {
+  addChannelMember,
+  addChannelMembersAtOnce,
+} from "../channel-members/members";
 import type { LocalAgents } from "../agents/local";
 import type { GitRead } from "../repos/git";
 import { repoDestinations } from "../repos/destinations";
@@ -2072,17 +2075,15 @@ export function createRelaySession(
       }
     },
   });
+  // A Solo chat admits people under its share rule; agents join by mention.
+  const solo = (channelId: string) =>
+    (
+      session.channels.list().channels.find((item) => item.id === channelId) ??
+      session.channels.get?.(channelId)
+    )?.channelType === "solo";
   const memberAdditions = createMemberAdditions(
     lifetime.signal,
     async (channelId, pubkey, intent): Promise<void> => {
-      // A Solo chat admits people under its share rule; agents join by mention.
-      const solo =
-        (
-          session.channels
-            .list()
-            .channels.find((item) => item.id === channelId) ??
-          session.channels.get?.(channelId)
-        )?.channelType === "solo";
       await addChannelMember(
         session,
         channelId,
@@ -2090,10 +2091,21 @@ export function createRelaySession(
         lifetime.signal,
         intent,
         writes?.local,
-        solo,
+        solo(channelId),
       );
     },
     writes?.local,
+    (channelId, pubkeys, intents) =>
+      addChannelMembersAtOnce(
+        session,
+        channelId,
+        pubkeys,
+        intents,
+        lifetime.signal,
+        solo(channelId),
+        undefined,
+        writes?.local,
+      ),
   );
   const recoverable = (
     subscribe: (listener: () => void) => () => void,
diff --git a/src/features/solo/share.test.ts b/src/features/solo/share.test.ts
index 6f0557f1af..f4494363b0 100644
--- a/src/features/solo/share.test.ts
+++ b/src/features/solo/share.test.ts
@@ -33,6 +33,7 @@ function setup() {
   let failLink = false;
   let chosenName: string | undefined;
   let rejectGrant = false;
+  let batches = false;
   let records: readonly import("../relay/outbox").OutgoingEvent[] = [];
   const publish = vi.fn(async (event: RelayEvent) => {
     if (event.kind === 9000 && rejectGrant)
@@ -40,10 +41,14 @@ function setup() {
     if (event.kind === 9 && failLink) throw new PublishRejected("Post denied");
     if (event.kind === 9000) {
       const id = event.tags.find(([tag]) => tag === "h")?.[1] ?? "";
+      // A relay without batch support adds only the first person named.
+      const named = event.tags.flatMap(([tag, value]) =>
+        tag === "p" ? [value ?? ""] : [],
+      );
       members.set(id, [
         ...new Set([
           ...(members.get(id) ?? []),
-          event.tags.find(([tag]) => tag === "p")?.[1] ?? "",
+          ...named.slice(0, batches ? named.length : 1),
         ]),
       ]);
     }
@@ -156,6 +161,9 @@ function setup() {
       query.mockImplementationOnce(async () => [archive]);
       await owner.session.archives.refresh();
     },
+    supportBatches: () => {
+      batches = true;
+    },
     rejectGrant: (value: boolean) => {
       rejectGrant = value;
     },
@@ -306,6 +314,69 @@ it("shares with a channel by granting only members missing from the chat, and po
   expect(t.published[0]?.tags).toContainEqual(["p", t.human.pubkey]);
 });
 
+it.each([true, false])(
+  "shares with several channel members in one grant (batch relay: %s)",
+  async (batchRelay) => {
+    const t = setup();
+    await t.ready();
+    if (batchRelay) t.supportBatches();
+    t.addDestination(t.human.pubkey);
+    t.addDestination(t.late.pubkey);
+    await shareChatsWithChannel(t.session, [chatId], channelId, {
+      signal: new AbortController().signal,
+    });
+    expect(t.members.get(chatId)).toEqual(
+      expect.arrayContaining([t.human.pubkey, t.late.pubkey]),
+    );
+    const named = t.published.map((event) =>
+      event.tags.flatMap(([tag, value]) => (tag === "p" ? [value] : [])),
+    );
+    const [first, second] = named[0] ?? [];
+    expect(named).toEqual(
+      batchRelay
+        ? [[first, second]]
+        : // Whoever the batch missed gets a single grant.
+          [[first, second], [second]],
+    );
+    expect(t.records().filter((item) => !item.acknowledged)).toEqual([]);
+  },
+);
+
+it("keeps each agent's grant to a Solo chat on its own receipt", async () => {
+  const t = setup();
+  await t.ready();
+  await t.setAgent();
+  t.supportBatches();
+  await grantSoloChatAccess(
+    t.session,
+    chatId,
+    [t.human.pubkey, t.bot.pubkey, t.late.pubkey],
+    new Map(),
+    new AbortController().signal,
+    () => {},
+    true,
+  );
+  expect(t.members.get(chatId)).toEqual(
+    expect.arrayContaining([t.human.pubkey, t.bot.pubkey, t.late.pubkey]),
+  );
+  // A recovering share can then finish the agent's exact Bot grant.
+  expect(
+    t.published.map((event) =>
+      event.tags.filter(([tag]) => tag === "p" || tag === "role"),
+    ),
+  ).toEqual([
+    [
+      ["p", t.human.pubkey],
+      ["p", t.late.pubkey],
+      ["role", "member"],
+    ],
+    [
+      ["p", t.bot.pubkey],
+      ["role", "bot"],
+    ],
+  ]);
+});
+
 it("retries a failed channel share without repeating confirmed grants", async () => {
   const t = setup();
   await t.ready();
diff --git a/src/features/solo/share.ts b/src/features/solo/share.ts
index 61834fcdfb..ddef8d797b 100644
--- a/src/features/solo/share.ts
+++ b/src/features/solo/share.ts
@@ -4,6 +4,7 @@ import {
 } from "../relay/channel-details-protocol";
 import {
   addChannelMember,
+  addChannelMembersAtOnce,
   canAddMembers,
   canShareSoloChat,
 } from "../channel-members/members";
@@ -37,7 +38,8 @@ export const soloChatLink = (id: string) =>
 export const soloChatLinkMessage = (id: string, name = id.slice(0, 8)) =>
   `[Chat: ${name.replace(/\s+/g, " ").replace(/[\\`[\]*_~<>&|]/g, "\\$&")}](${soloChatLink(id)})`;
 
-/** Exact selected people are grants to the chat, not the destination or its parent. */
+/** Exact selected people are grants to the chat, not the destination or its parent.
+ * Everyone goes in one batch first; anyone it didn't add gets a single addition. */
 export async function grantSoloChatAccess(
   session: RelaySession,
   channelId: string,
@@ -52,13 +54,27 @@ export async function grantSoloChatAccess(
 ) {
   if (people.length > 100 || new Set(people).size !== people.length)
     throw new Error("Choose at most 100 distinct recipients.");
+  const added = await addChannelMembersAtOnce(
+    session,
+    channelId,
+    people,
+    intents,
+    signal,
+    soloParticipant,
+    beforeDispatch,
+  );
   for (const key of people) {
     signal.throwIfAborted();
+    const intent = intents.get(key) ?? {};
+    intents.set(key, intent);
+    if (added.has(key)) {
+      intent.confirmed = true;
+      onConfirmed(key);
+      continue;
+    }
     // Channel audiences omit archived identities; direct selections still fail explicitly.
     if (skipArchived && archiveHides(session.archives, key, session.viewer))
       continue;
-    const intent = intents.get(key) ?? {};
-    intents.set(key, intent);
     await addChannelMember(
       session,
       channelId,