Multi-Agent Coherence

Why Single-Player AI Tools Don't Scale to Teams — and the Architecture That Does Byiringiro Thierry · March 2026

1. Abstract

Three years into the LLM-as-product era, every dominant AI tool is single-player. ChatGPT, Claude.ai, Cursor, Midjourney, ElevenLabs — one human, one model, private workspace. This has been the path of least resistance, technically and commercially: SSO is easier than shared workspaces; private chat logs are easier than CRDTs; per-seat pricing is easier than team-pricing.

But the most valuable workflows in real organizations are not solitary. They are teams — sales pods, engineering squads, research groups, customer-success teams — who need to share context, artifacts, and increasingly AI conversations. Forcing a sales team to operate via N parallel ChatGPT sessions is the 2026 analog of forcing them to operate via N parallel Word documents. It works, until Slack ships and the world moves on.

This paper formalizes the coherence problem for team AI, surveys the early entrants, and proposes a four-primitive framework. I'm building Chord on these primitives; the framework is generalizable.

2. The four dimensions of multi-agent coherence

2.1. Temporal coherence. When Maya asks an AI agent about the Acme deal on Monday, and Adaora asks the same agent about the same deal on Friday, the agent should remember Monday's conversation. Trivially true in a single-user product (chat history). Non-trivial in a multi-user product (whose history, with what permission?).

2.2. Social coherence. When Maya asks the agent about Acme and Adaora is also on the deal, the agent's answer should reflect what Adaora knows that Maya doesn't. The agent has a team-aware notion of the player base. This is the social-graph problem from NPCs (see From Scripted to Sentient) applied to professional tools.

2.3. Semantic coherence. The team's shared vocabulary — internal product names, customer codes, deal-stage definitions — should be common knowledge across every agent conversation. ChatGPT-style single-user setups can be fine-tuned per user; team setups need team fine-tuning that updates as the team's vocabulary evolves.

2.4. Action coherence. When an agent takes an action (drafts an email, updates a CRM field, creates a Linear ticket), the rest of the team should see it. Action-as-conversation, not action-as-side-effect. A draft email visible to one rep, invisible to her teammates, is a coordination failure waiting to happen.

The failure modes of current "team" AI tools — Glean, Notion AI, ChatGPT Enterprise — line up against these four dimensions. Most score 2 or 3 of 4 but rarely all 4.

3. Surveying the field, calibrated

Glean

Strong on semantic coherence: an indexed company knowledge graph that any user's queries can hit. Weak on temporal coherence: each user's chat history is private. Weak on social coherence: the agent doesn't know who's on which deal. Weak on action coherence: actions are side-effects, not first-class shared artifacts.

Notion AI

Strong on action coherence (everything happens inside the same Notion page, visible to the team). Weak on temporal coherence (chat threads are awkwardly embedded; agent doesn't have first-class memory across pages). Weak on social coherence (no model of who's working on what).

ChatGPT Enterprise / Claude Team

Strong on semantic coherence (custom GPTs, project docs). Weak on the rest. The chat itself remains private; team-aware behavior is bolt-on.

Slack AI / Microsoft Copilot Chat

Strong on temporal coherence (channel histories are shared). Weak on semantic coherence (no schema for organizational vocabulary). Mid on action coherence (limited tool-use). Weak on social coherence (no deal/account graph).

The pattern: existing tools score well on 1-2 dimensions because they were built for adjacent use cases (search → Glean, docs → Notion, chat → Slack, Q&A → ChatGPT). None were built for the team-AI workflow as a first-class primitive. That's the design space Chord lives in.

4. The four primitives

4.1. Shared context windows.

A room (in Chord's vocabulary) has a shared context window — a transcript of every interaction (human and AI) tied to a specific business entity (Acme deal, Globex account, Initech renewal). When any team member sends a message in the room, the LLM context is the entire room history, not the individual user's history.

Implementation note: this scales to ~100K messages per room before context-window economics force compaction. Compaction strategy: a "room summarizer" agent runs every 100 messages, producing a structured summary; the prompt becomes [structured summary] + [last 30 raw messages].

4.2. Witness-graph permissions.

Not every user can see every room. Permission is granted at the entity level: who has access to the Acme deal sees the Acme room. The witness graph is the projection of this access pattern.

For AI context: when Maya asks the agent about Acme, the agent's response can reference any context Maya is permitted to see. But the agent itself is the privacy boundary — the agent's underlying knowledge across all rooms is fenced off by the witness graph. Implementation: a per-message ACL check on every retrieval; no shortcuts.

4.3. Agent inheritance.

When a team member leaves and a new one joins, the new member should inherit the team's accumulated context with one click. Onboarding from cold to "knows the Acme deal, the Globex account, and the Initech renewal" should take 5 minutes, not 5 weeks.

Mechanism: an onboarder agent runs across the new member's assigned rooms, produces a per-room briefing tailored to their role, and surfaces "things you should know" before their first internal meeting. The agent retains the current state; the new member inherits a synthesized view of it.

This primitive — agent inheritance — is the killer feature for fast-growing teams. The unit-economic argument is concrete: a Series-A sales team turning over 30% YoY pays for itself the moment a new BDR is productive 3 weeks earlier than they would have been.

4.4. CRDT-like state merge.

Two team members in the same room, conversing with the same agent simultaneously. Both make changes (one drafts an email; the other updates a deal-stage). Without coordination, you get conflicts.

The right approach is conflict-free replicated data types (CRDTs) borrowed from collaborative-editing infrastructure (Figma, Linear). Every action in a room is a commutative operation. Email-drafts merge by union; deal-stage updates merge by "last-writer-wins with conflict surfacing." AI actions are agent-authored commits in the same model.

The CRDT model gives multi-agent rooms the same offline-first, conflict-free experience that Figma gave multi-user design.

5. Implementation in Chord

// Chord/lib/room/postMessage.ts (simplified)
export async function postMessage(roomId: string, userId: string, text: string) {
  // 1. Verify witness graph
  const room = await db.rooms.findById(roomId);
  if (!await witnessGraph.canSee(userId, room.entityId)) {
    throw new Error("forbidden");
  }

  // 2. Append to shared context (CRDT op)
  const op = await crdt.append(roomId, {
    type: "message",
    author: userId,
    text,
    ts: Date.now(),
  });

  // 3. Parse @mentions for AI agents
  const mentions = parseMentions(text);  // ["@research", "@coach"]
  const agentTasks = mentions.map((handle) =>
    invokeAgent(handle, { roomId, triggeredBy: userId, text }),
  );

  // 4. Stream agent replies into the room as agent-authored commits
  await Promise.all(agentTasks);

  return op;
}

// Each agent runs against the *room's* shared context, not the user's individual history
export async function invokeAgent(handle: string, ctx: AgentContext) {
  const room = await loadRoomContext(ctx.roomId);
  const agent = agents[handle];
  const response = await agent.run({
    sharedHistory: room.messages,
    sharedFacts: room.semanticFacts,
    actorPermissions: await witnessGraph.permissionsFor(ctx.triggeredBy),
    tool_use: room.permittedTools,
  });
  await crdt.append(ctx.roomId, {
    type: "agent_message",
    author: handle,
    text: response.text,
    actions: response.actions,
    ts: Date.now(),
  });
}

The interesting part is not the LLM call. It's the four primitives wrapped around it: witness-graph check, CRDT append, agent dispatch on @mentions, and the agent reading the shared history, not the user's history.

6. Open problems

6.1. Agent attribution. When @research drafts an email and Maya sends it, who "wrote" the email — the agent or Maya? For internal reporting and audit, this matters. The clean answer: every AI action is attributed to both the human who triggered it and the agent who produced it. UI surfaces both. This is what's been wired in Chord.

6.2. Hallucination liability. A research agent that quotes a competitor's "fact" the user later sends to a customer creates a B2B liability. The mitigation: source-citation in every agent response, with strong UX preventing copy-paste of un-cited content. Easier in theory than in practice — sales reps are speed-driven, not citation-driven.

6.3. Cross-room transfer. Maya learns that Acme's CFO just stepped down (mentioned in the Acme room). She's also working on Globex, who's a competitor. Should the agent in the Globex room know about the CFO change? Witness-graph says "Globex room is a different room; no auto-transfer." Real-world business judgment says "yes, this is competitive intel that should propagate." Open problem.

6.4. Performance at scale. A 50-room team running 30 simultaneous agent conversations is non-trivial infrastructure. Per-room context loading + retrieval + LLM dispatch is the hot path. Caching is hard because writes invalidate room state in real-time. Hard work, soluble work.

7. Implications

For AI tooling startups. The next decade's biggest AI products are not new ChatGPTs. They are team-AI tools for specific verticals — sales (Chord), customer success, engineering teams, research labs, legal teams. Each vertical's team-AI tool is a billion-dollar opportunity. Single-player AI is a plateau.

For incumbents. Slack, Notion, and Salesforce all face the same question: do we evolve into the team-AI substrate, or do we get disintermediated by one? Slack's AI strategy in 2026 is the bellwether to watch.

For enterprise IT. Permissions in team-AI tools are first-order security. The witness-graph implementation determines whether your AI tool is a sleeper data-leak vector. Buyers will start to scrutinize this; vendors that don't have a clean answer will lose enterprise deals.

For founders. The four-primitive framework is a checklist, not a roadmap. If your team-AI product cleanly answers temporal, social, semantic, and action coherence, you're ahead of every competitor in the field. If you only have 2 of 4 working, you're competitive with Glean and Notion AI — and the bar will rise quickly.

8. Conclusion

The single-player era of AI tools is ending. The team-AI era is just beginning. The architectural primitives — shared context windows, witness-graph permissions, agent inheritance, CRDT state merge — are not exotic. They are well-understood techniques borrowed from collaborative-editing, social-graph, and distributed-systems infrastructure. What's missing is the discipline to build them into AI tooling from day one, rather than retrofit them on a single-player chat product.

That's the bet behind Chord. The framework generalizes far beyond sales.

---

References

1. Shapiro, Preguiça, Baquero, Zawirski — Conflict-Free Replicated Data Types (2011)
2. Anthropic — Claude Sonnet 4.6 Constitutional AI for Multi-User Workspaces (2026)
3. Park et al. — Generative Agents: Interactive Simulacra of Human Behavior (2023)
4. Liang et al. — Holistic Evaluation of Language Model Tools in Real Workflows (2025)
5. Wang et al. — MERIT: A Benchmark for Multi-Agent Reasoning in Team Settings (2025)
6. Glean Technical Architecture Whitepaper (2024)