What Is a Multi-Agent, Multi-User System (MAMU)?

Many humans and many agents introduce private/shared state, identity, permissions, ownership and write-back concerns. A MAMU, or multi-agent, multi-user system, is a useful working term for a system where people and agents create, receive and reuse state together. It is not a universal industry standard.

Working thesis: When both users and agents scale, context becomes an organizational systems problem rather than only orchestration.

Why this matters for AI agents

An AI agent does not work from organizational reality directly. It works from the instructions, tools, memory, retrieved material and task state that reach its context window. That makes context selection part of the system architecture rather than a cosmetic prompt decision.

For one-off assistance, an imperfect context set may produce an inconvenient answer. For long-running or tool-using agents, the same weakness can persist across steps, be written into memory, propagate to another agent, or influence an external action. The engineering target is therefore not maximum information. It is sufficient, current and applicable information for the task at hand.

This is also why raw retrieval metrics tell only part of the story. A system can retrieve text that is semantically relevant yet still be wrong for the current project, user, environment or point in time. Conversely, an important constraint may have low lexical similarity to the user’s request but still be essential to safe execution.

A concrete example

A platform team, security team and several specialized agents need different context scopes while still sharing approved knowledge.

A practical architecture

1. 1 user / 1 agent. A private session can keep task state local, but it still needs a clear boundary around what may be retained.
2. Many users / 1 agent. The agent must distinguish users, permissions and task scopes instead of treating every request as one memory stream.
3. 1 user / many agents. Multiple agents need shared task identifiers and handoff state so one agent does not mistake another agent’s local notes for team truth.
4. Many users / many agents. Identity, workspace boundaries and ownership become first-class system data, not labels added after retrieval.
5. Shared governed context. Reusable knowledge needs explicit scope, lifecycle and human approval before it can travel across users and agents.

Design principles

• Keep human and agent identity explicit.

• Separate private memory from shared knowledge.

• Propagate permissions with context.

• Keep provenance, lifecycle state and permissions attached as context moves across tools and handoffs.

• Evaluate context quality against the task outcome, not only similarity scores or token counts.

How AuzzurA approaches this

AuzzurA frames human + AI work as a shared-context problem. People and agents need different visibility, but approved reusable learning still needs an explicit path across those boundaries.

Questions to ask before implementing this pattern

• What exactly are we persisting: raw source, memory, candidate knowledge or approved knowledge?
• Who owns an item, and who can change its status?
• How is scope represented across organization, team, project, environment, user, agent and task?
• How do we know when an item is stale, superseded or in conflict?
• Can we reconstruct which context reached a participant during a specific run?
• What learning from the run should return to shared context, and what review is required before reuse?

These questions tend to outlast individual model, vector-store and graph-engine choices because they define the organizational semantics around those components.

Sources and further reading

• AIM: A Privacy-Aware Interoperable Memory Framework for Multi-Agent Multi-User LLM Systems
• Collaborative Memory: Multi-User Memory Sharing in LLM Agents
• Julep — Multi-Agent Multi-User Sessions
• Microsoft Learn — Multi-agent patterns