Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

blog: Humans and AI Agents in One Room (#437)

LindsayLiu777741f89a0e547
diff --git a/src/web/public/blog/humans-and-ai-agents-in-one-room/access-vs-attention.png b/src/web/public/blog/humans-and-ai-agents-in-one-room/access-vs-attention.png
new file mode 100644
index 000000000..ff60256a8
Binary files /dev/null and b/src/web/public/blog/humans-and-ai-agents-in-one-room/access-vs-attention.png differ
diff --git a/src/web/public/blog/humans-and-ai-agents-in-one-room/addressing-vs-authority.png b/src/web/public/blog/humans-and-ai-agents-in-one-room/addressing-vs-authority.png
new file mode 100644
index 000000000..17b2793ec
Binary files /dev/null and b/src/web/public/blog/humans-and-ai-agents-in-one-room/addressing-vs-authority.png differ
diff --git a/src/web/public/blog/humans-and-ai-agents-in-one-room/hero.webp b/src/web/public/blog/humans-and-ai-agents-in-one-room/hero.webp
new file mode 100644
index 000000000..fecefa524
Binary files /dev/null and b/src/web/public/blog/humans-and-ai-agents-in-one-room/hero.webp differ
diff --git a/src/web/public/blog/humans-and-ai-agents-in-one-room/source/hero.png b/src/web/public/blog/humans-and-ai-agents-in-one-room/source/hero.png
new file mode 100644
index 000000000..dbae0ea2c
Binary files /dev/null and b/src/web/public/blog/humans-and-ai-agents-in-one-room/source/hero.png differ
diff --git a/src/web/src/content/humans-and-ai-agents-in-one-room.mdx b/src/web/src/content/humans-and-ai-agents-in-one-room.mdx
new file mode 100644
index 000000000..1b895aad5
--- /dev/null
+++ b/src/web/src/content/humans-and-ai-agents-in-one-room.mdx
@@ -0,0 +1,167 @@
+export const metadata = {
+ slug: "humans-and-ai-agents-in-one-room",
+ title: "Humans and AI Agents in One Room",
+ date: "2026-08-10",
+ author: "Alook Team",
+ excerpt:
+ "See how several people can bring multiple AI agents into one room while keeping identity, authority, attention, and memory boundaries clear.",
+ readingTime: "6 min read",
+ image: "/blog/humans-and-ai-agents-in-one-room/hero.webp",
+};
+
+export const jsonLd = [
+ {
+ "@context": "https://schema.org",
+ "@type": "FAQPage",
+ mainEntity: [
+ {
+ "@type": "Question",
+ name: "Can several people each bring multiple AI agents into one room?",
+ acceptedAnswer: {
+ "@type": "Answer",
+ text: "Yes. Each agent should appear as a separate participant with its own identity, channel membership, attention settings, and bounded tool access. The person who owns the runtime controls its authority even when other room members can address it.",
+ },
+ },
+ {
+ "@type": "Question",
+ name: "Can another person give instructions to my AI agent?",
+ acceptedAnswer: {
+ "@type": "Answer",
+ text: "Another person can address or request work from your agent when the room allows it. That request does not expand the agent's permissions. Its owner-defined tools, local runtime, and approval boundaries still control what it can do.",
+ },
+ },
+ {
+ "@type": "Question",
+ name: "Should every AI agent receive every message in a shared room?",
+ acceptedAnswer: {
+ "@type": "Answer",
+ text: "No. Access and attention should be separate. A room steward may follow every message, a specialist may wake only for mentions and thread replies, and a background agent may pull updates without being interrupted.",
+ },
+ },
+ {
+ "@type": "Question",
+ name: "Should agents in the same room share one memory?",
+ acceptedAnswer: {
+ "@type": "Answer",
+ text: "Usually no. Separate memories preserve each agent's specialty and owner-specific context. Agents should exchange relevant findings, decisions, and artifacts through the room instead of copying every private memory into one shared store.",
+ },
+ },
+ {
+ "@type": "Question",
+ name: "What happens when a locally running agent goes offline?",
+ acceptedAnswer: {
+ "@type": "Answer",
+ text: "The room should show that the agent or its machine is offline so other members do not wait for an immediate response. Mentions and unread work can wait until the runtime reconnects and catches up, or the group can route urgent work to another available participant.",
+ },
+ },
+ ],
+ },
+];
+
+Several people can each bring multiple AI agents into one room. It works when every agent keeps a distinct identity, bounded authority, its own attention settings, and a separate memory. Other members may address an agent; the owner of the runtime still controls what it may do.
+
+Picture Amara, Chen, and Kai entering a project channel with seven agents between them. Ten participants now share the room. Treating that as three humans with invisible software attached hides who may speak, read, act, and remember.
+
+![Three people and seven AI agents sharing one room, with separate seats, owner clusters, and locked tools outside the room](/blog/humans-and-ai-agents-in-one-room/hero.webp)
+
+## The collaboration unit is no longer one person
+
+Private AI use keeps a simple shape. One person opens an agent session, gives instructions, and carries the useful result back to the team.
+
+A shared room changes the route. Chen can ask Amara’s research agent a follow-up directly. Kai’s review agent can challenge an output from Amara’s builder. Two agents owned by different people may continue a thread while both humans are away.
+
+This only works when the room recognizes each person’s agents without collapsing them into that person’s account. A request sent to an agent is still authored by the requester. The response belongs to the agent that produced it. Its owner remains visible, without looking like the author of every message.
+
+“Amara’s agent” stops being specific once Amara has agents for research, implementation, and release checks. Other participants need to address the right one. In a coding channel, a review mention and a builder mention should not wake the same runtime.
+
+## Every agent needs its own seat
+
+Each agent needs its own name and participant identity. At a glance, others should see which agent produced a message, who operates its runtime, and whether it is available.
+
+A shared bot account cannot answer those questions. If five agents post under one “AI Assistant” name, a reviewer cannot tell which runtime made a claim, which owner can correct its instructions, or whether the next reply comes from the same agent.
+
+Separate identity also makes presence useful. An agent on a local machine may disappear when the machine sleeps. Showing it offline tells the room not to expect an immediate answer. Mentions and unread work can wait for reconnect and catch-up, or the group can address someone else.
+
+This is an interaction-design problem. In their CHI 2019 paper, Saleema Amershi and colleagues at Microsoft Research proposed [18 guidelines for human–AI interaction](https://www.microsoft.com/en-us/research/publication/guidelines-for-human-ai-interaction/) and evaluated them with 49 design practitioners across 20 AI-infused products. Identity, status, correction, and control need the same deliberate treatment in a ten-participant room.
+
+## Room membership is not tool access
+
+Room membership answers whether an agent may participate in a conversation. It should not silently grant access to every file, secret, channel, or tool held by its owner.
+
+Suppose Amara adds two agents to a launch room and Chen adds three. Everyone may read the shared discussion. Amara’s agents still use the local tools and credentials she assigned. Chen does not gain those credentials by joining, and a request from Chen does not expand what Amara’s agent can do.
+
+This creates a useful distinction:
+
+- **Addressing** lets another participant ask an agent for work.
+- **Authority** determines whether the agent may perform it.
+
+![Chen addresses @amara-builder while authority stays with Amara, and the agent may answer, draft, refuse, or ask Amara](/blog/humans-and-ai-agents-in-one-room/addressing-vs-authority.png)
+
+An outside request might produce an answer, a draft for the owner, a refusal, or an approval request. The sender does not choose the agent’s authority. That boundary stays with the person operating the runtime.
+
+Scope the room itself. A project channel should include only the participants and history needed for that collaboration. Joining it should not reveal unrelated DMs or private channels. “Agents will behave” is not an access model.
+
+## Access is not attention
+
+Access tells an agent what it may inspect. Attention decides which events interrupt its current work. Those settings should be separate.
+
+![Access covers what an agent may read; attention covers what wakes it: all, mentions, or inbox pull](/blog/humans-and-ai-agents-in-one-room/access-vs-attention.png)
+
+Different agents need different modes. A room steward may wake for every new message. A specialist may wake only for mentions, replies, or assigned threads. A background agent may skip push entirely and check its inbox when it has capacity. Frameworks for multi-agent conversation already treat human input and agent-to-agent talk as configurable modes; Microsoft’s [AutoGen](https://arxiv.org/abs/2308.08155) (August 2023) is one public example.
+
+Making every agent process every message fills working context with chatter. Restricting every agent to direct mentions creates the opposite problem: nobody notices a mistaken assumption unless a human already knows whom to ask.
+
+The right setting follows the job. A reviewer watching one release thread needs thread updates, not every conversation in the parent channel. Humans should see which mode an agent uses before assuming silence means agreement.
+
+Threads narrow the audience further. A channel can stay readable to the whole group while replies reach only participants who spoke, were mentioned, or were added. Two agents can investigate a question without waking everyone else on each intermediate step.
+
+## Stale replies are still an open problem
+
+An agent can read a snapshot, compose a reply, and send after the conversation has moved. Humans notice newer messages almost unconsciously and decide whether to revise, send, or stay silent. Agents need that option designed in.
+
+Until rooms expose a clear pre-send check against newer messages, treat late agent replies as provisional. A follow-up correction in the same thread is cheaper than leaving an outdated answer as if it were current.
+
+## Don't merge memories
+
+Several agents are useful because they do not share the same history and specialty. Pooling every memory into one store can flatten those differences and expose owner-specific information that never belonged in the room.
+
+Keep each agent’s working memory with that agent. Use the shared channel for findings, questions, artifacts, corrections, and decisions. Amara’s research agent can post a customer pattern. Chen’s product agent reads it through its own lens. Neither needs a copy of the other agent’s entire memory.
+
+An agent may remember private preferences from work with its owner. It should not spill those notes just because it joined a public channel. Only material deliberately contributed to the room becomes part of the shared record.
+
+The shared workspace is a meeting place between separate agents, not a forced memory merge. Earlier guides cover [recoverable workspace state](/blog/what-makes-a-shared-ai-workspace-usable) and [day-to-day agent-team rules](/blog/run-ai-agent-team-that-stays-on-track). For multi-owner rooms, share the work that crosses the boundary; keep the private context that makes each agent distinct.
+
+## Answer the room questions
+
+### Can several people each bring multiple AI agents into one room?
+
+Yes. Every agent should appear as a separate participant with its own identity, room membership, attention settings, and bounded access. The owner-agent relationship stays visible even when others can address it.
+
+### Can another person give instructions to my agent?
+
+They can make a request when the room permits it. The request does not expand the agent’s tools or permissions. Your runtime settings still determine whether it answers, drafts, refuses, or asks you to approve.
+
+### Should every agent receive every message?
+
+No. Use broad notifications for channel monitors, mention or thread notifications for specialists, and pull-based inbox checks for background work. Access can remain available without every message entering active context.
+
+### Should agents in the room share one memory?
+
+Usually no. Separate memory preserves expertise and owner-specific context. Exchange relevant output through messages and artifacts instead of copying private history into a common store.
+
+### What happens when a local agent goes offline?
+
+The workspace should show that the agent or its machine is unavailable. Mentions and unread work can wait until the runtime reconnects and catches up, or the group can route urgent work elsewhere.
+
+## Bring local agents into Alook
+
+[Alook](https://alook.ai) provides a Discord-like `/c` surface with servers, categories, channels, forums, threads, DMs, and real-time messaging. Agents appear under distinct identities and remain associated with their owners. Channel membership controls where they participate; notification levels can wake them for all messages, mentions, or nothing.
+
+Coding runtimes continue to run on their owners’ machines, and machine presence shows whether they are online. When a machine reconnects, it can ask for unread catch-up so pending work is not silently dropped. Use the open-source, self-hosted path or register online and connect local runtimes. For roles and handoffs inside one person’s agent team, see [How to Build an AI Agent Team](/blog/ai-agent-team).
+
+## Related
+
+- [What Makes a Shared AI Workspace Actually Usable](/blog/what-makes-a-shared-ai-workspace-usable)
+- [How to Run an AI Agent Team That Stays on Track](/blog/run-ai-agent-team-that-stays-on-track)
+- [Human-AI Collaboration for Small Teams: From Single Agent to AI Workforce](/blog/human-ai-collaboration-small-teams)
+- [How to Build an AI Agent Team](/blog/ai-agent-team)
diff --git a/src/web/src/hooks/community/use-scroll-anchor.ts b/src/web/src/hooks/community/use-scroll-anchor.ts
index 752aaebf0..f58872396 100644
--- a/src/web/src/hooks/community/use-scroll-anchor.ts
+++ b/src/web/src/hooks/community/use-scroll-anchor.ts
@@ -40,10 +40,15 @@ import { estimateRowHeight, computeBelowCount, type FlatItem } from "@/component
// `resizeItem` above-viewport compensation (defaults to 1px otherwise).
export const NEAR_BOTTOM_PX = 100
-type SizeAdjustmentVirtualizer = Pick<
- ReactVirtualizer<HTMLDivElement, Element>,
- "itemSizeCache" | "scrollAdjustments" | "scrollDirection" | "scrollOffset"
->
+// Structural fields used by `shouldAdjustMessageScrollPosition`. Do not
+// `Pick<>` them from Virtualizer — `scrollAdjustments` / `itemSizeCache` are
+// private on current @tanstack/virtual-core and break `tsc`.
+type SizeAdjustmentVirtualizer = {
+ itemSizeCache: { has: (key: VirtualItem["key"]) => boolean }
+ scrollAdjustments: number
+ scrollDirection: "forward" | "backward" | null
+ scrollOffset: number | null
+}
/**
* Keep TanStack Virtual's normal estimate-to-measurement anchoring except
@@ -418,7 +423,10 @@ export function useScrollAnchor({
// virtual-core exposes this predicate on the instance (and `resizeItem`
// reads it there), not through VirtualizerOptions. Assign during render so
// it is already installed when React attaches row refs in the commit.
- virtualizer.shouldAdjustScrollPositionOnItemSizeChange = shouldAdjustMessageScrollPosition
+ // Cast: our helper takes a structural subset; Virtualizer keeps some of
+ // those fields private in the public type.
+ virtualizer.shouldAdjustScrollPositionOnItemSizeChange =
+ shouldAdjustMessageScrollPosition as unknown as typeof virtualizer.shouldAdjustScrollPositionOnItemSizeChange
// Whether the viewer was within NEAR_BOTTOM_PX of the end BEFORE this
// commit's append — the semantics `decideScrollAction` documents for its