Ankole outlines multi-user agent architecture: events, permissions and organizational memory

The team describes its Business Harness design for fast and slow paths, shared state, Actor orchestration and dynamic permissions. Formal verification covers the modeled core permission state machine; it does not replace security checks of the full deployment, external interfaces or implementation.
Editorial correction (November 19, 2026): The independence assumption for the probability calculation has been added. The formal proof covers only the explicitly modeled core permission state machine.
Following coding agents, Personal Agent products such as Muse and Grok Bot are also maturing rapidly. Many teams have tried introducing them into organizations, either deploying an instance for every member or connecting the same agent to a departmental group chat. Yet agents that perform reliably for one person consistently fall far short of expectations in multi-user collaboration.
This is because, when using an agent, users manually take on several supporting responsibilities: assigning tasks, intermittently monitoring execution, and sharing local files and account credentials. In an organizational environment, this human-agent collaboration loop breaks down in four ways:
- Diverging understanding: Each member's Personal Agent maintains its own private context. A business rule just updated in one group is not synchronized to other members' agents, and the team soon starts working to different standards.
- Context-window information leakage: A single-user agent assumes that any information it can read may be used in its answers. Once an agent connected to high-privilege interfaces enters a multi-user group chat, it cannot distinguish information meant only for itself from information everyone present is entitled to see.
- Fragmented state: Without shared structured storage, members and their respective agents can synchronize data only by sending file copies back and forth. Concurrent changes by multiple people quickly produce conflicting versions.
- Frequent polling may add unnecessary model calls. If each round is assumed to have a 1% error rate, all rounds are independent and all errors count as the same type, the probability of at least one error across 288 rounds is about 1−0.99^288≈94.5%. Real workflows differ in error correlation, detection and recovery mechanisms, so this figure cannot be applied directly.
If coding agents address individual development tasks and Personal Agents handle a person's affairs across sessions, entering an enterprise requires a third form: the Business Agent. It operates for the whole organization, allowing members in different roles and multiple specialist agents to collaborate over the same data, permissions and boundaries of responsibility.

While building Ankole, an open-source Business Agent system, we established two central directions. The first is a Business Harness designed natively for collaboration among multiple actors, taking over event scheduling, dynamic permissions, organizational memory and long-running fault tolerance at the system level. The second follows a philosophy of malleable software: AI can generate higher-level features as needed and retire them after use, while all feature state is retained in a shared database. The discussion below focuses on the first direction: the design philosophy and engineering implementation of the Business Harness.
Four design principles for a Business Harness
1. Separate fast and slow paths: scripts handle routine operation; models handle exceptions and rule updates
Just as mature teams do not hold meetings to approve every routine order, large models—with expensive tokens and stochastic behavior—are ill suited to acting directly as high-frequency executors of everyday work.

The continuous availability organizations need should come from separate fast and slow paths with on-demand activation. Normally, the large model sleeps without consuming resources, while scripts written by the model handle high-frequency routine flows with clear rules. Events wake the model only for new situations outside the rules, key metrics that exceed thresholds, or nonstandard disputes. The model thus moves to the slow path, focusing on exceptions and rewriting scripts as business rules change, enabling Harness-RSI for business workflows.
2. Calculate permissions dynamically from the audience present, rather than binding them to static accounts
A Personal Agent normally assumes it can see whatever its owner can see. In multi-user collaboration, however, access control requires an explicit calculation: before each activation, intersect the permissions of the current agent, the person asking and everyone present; information that any one person is not entitled to see must not enter the context. The same agent may retrieve sensitive information in a private chat with the person in charge, but once it joins a 30-person departmental group, those data must be automatically hidden from retrieval.

Narrowing the read-permission intersection alone is insufficient. Cross-role collaboration also has two opposing requirements. Frontline roles often need to submit business records without being entitled to view an entire sensitive underlying table. Meanwhile, disputes over specialist terms may require judgments based on highly classified domain material; simply taking the intersection would make collaborative investigation impossible. For the former, the system introduces a fixed write channel, reviewed and signed by the responsible person, between full visibility and total prohibition. Frontline roles and their agents can submit parameters only in a specified format and cannot read the underlying table. For the latter, the system divides agents into two kinds: each member receives a personal assistant reflecting their everyday permissions, while roles such as legal and finance have functional agents with independently authorized scopes. For cross-departmental compliance issues, the personal assistant starts a separate background session with a functional agent to request help. The functional agent retrieves restricted material in an isolated context, labels untrusted external text for isolation, and returns only a sanitized conclusion to the original conversation.
3. Organizational memory as a multi-perspective projection of the world: a shared relationship directory with permissions inherited in real time
Existing long-term-memory approaches often fit poorly within organizations. Vector retrieval provides semantic similarity without causal reasoning, making obsolete rules likely to be retrieved alongside new decisions. Compiled knowledge bases such as LLM Wiki extract new material and rewrite it into the relevant entity-summary pages. In a multi-user organization, that approach breaks confidentiality boundaries: once a confidential contract and a public weekly report have been distilled into the same supplier page, ordinary members reading it gain unauthorized access. If access to a source document is later revoked, its content, already blended into natural-language paragraphs, cannot be removed separately. Conversely, if the list of people allowed to see a memory is fixed in its record at extraction time, the visibility of historical memories becomes outdated after departmental changes.

Organizational memory should therefore be a multi-perspective projection of the world that varies with the reader's identity. The entire company shares the same relationship structure, without hard-coding permissions into the memory layer. What everyone shares is only a relationship directory containing no specific secrets: it records customer, supplier and project names and their connections, aligning departments around the same business map without exposing details. Specific memories attached to the directory fall into two categories. Those supported by documents or receipts are recorded as objective facts; inferences by individuals or agents are recorded, with attribution and a timestamp, as subjective judgments. Later, actual outcomes are used to continually calibrate the originator's historical accuracy, preventing personal guesses from becoming organizational consensus directly. Every memory links to its original document or conversation, and the source's current permissions are checked at read time. Once access to a source is revoked or it moves into a confidential directory, the associated memories immediately disappear for unauthorized readers, without rerunning the model.
Orchestrating a network of actors with the Actor model: from static snapshots to owned state and hierarchical supervision
Most mainstream agent harnesses currently use an agentic loop plus a checkpointer for state persistence: context is saved as a database snapshot at each step, then reloaded to resume after an interruption. This mechanism readily encounters concurrency bottlenecks when multiple people interact with multiple agents. A snapshot is only a static database record. While the model performs a time-consuming background operation, revised group-chat instructions, external callbacks and cross-departmental replies may arrive together; concurrent processes editing the same saved state can easily overwrite one another.

The Actor model is a distributed parallel-computing model that encapsulates private state, execution logic and a message inbox in a single resident runtime unit, making it particularly suitable for these problems. Each conversation and specialist agent is an independent Actor. Even while the underlying system awaits a model response, interruptions, revised instructions and approval results can enter its inbox at any time. The Actor itself merges them in sequence, queues them, or interrupts and restarts, avoiding overwritten progress without external locks. The system also distinguishes external messages from agents' own utterances, preventing multiple agents in a group from endlessly triggering one another's replies. Cross-departmental collaboration becomes asynchronous communication between peer Actors: they respond immediately when active, save progress and sleep automatically while waiting for approval or idle, and wake again when new messages arrive.
For timeouts or environment failures, hierarchical supervision separates code execution into temporary sandboxes containing no long-term secrets. A damaged sandbox can be destroyed and rebuilt without affecting the main conversation. Irreversible actions such as payments, price changes or external messages are entered in a durable action ledger before being sent. After recovery, the system checks external receipts before deciding whether to continue, avoiding duplicate execution. When a member leaves or changes roles, updating the permission version once simultaneously terminates their Actors, external authorizations and in-flight write-backs.
From architectural philosophy to system engineering: Ankole's implementation

In the open-source Ankole system, we turned the full Harness into a scalable distributed architecture, with native integration into online workspaces (Pods), Feishu, DingTalk, WeCom and Slack. In Ankole's control plane, we use Erlang/OTP to handle high concurrency and availability as hundreds or thousands of long-running conversations send and receive messages simultaneously. WhatsApp once used the same technology to achieve the remarkable productivity of serving 500 million users with just 32 engineers.
In the permissions and memory-retrieval path, calculating the visibility intersection for everyone present before each activation must be fast enough. Ankole uses CTE queries to compute each member's visible scope within a multilevel directory tree and compresses it into a binary bitmap. A Rust core embedded in the control plane then performs bitwise intersection within microseconds. It also supports a PBAC permission model that uses CEL expressions to evaluate dynamic policy conditions.
The team says it used Lean 4 to verify the modeled core permission state machine. Formal proofs hold only within the explicitly defined model, assumptions and properties. They do not establish that the implementation code, deployment configuration, external tools or complete production system can never permit unauthorized access.
Conclusion
Personal Agents have demonstrated that a model paired with a suitable Harness can do a great deal of work for one person. As agents move into teams and face everyday collaboration among multiple people and multiple agents, systems need an organization-oriented Business Harness. As foundation models continue to evolve, peripheral patches compensating for early model weaknesses will gradually disappear. But the underlying constraints of organizational operations will remain: the faster models generate code and the longer their autonomous execution chains, the more teams need business state consolidated into a single source of truth, information visibility dynamically narrowed to everyone present, key metrics defined consistently, and responsibility for irreversible external actions assigned to specific people.

As the open-source implementation of this architecture, Ankole has released all its code at https://github.com/AgentBull/ankole. Discussion is welcome.
This article comes from Synced. Author: Synced.
After reading
Join the AINRK community
Read how to join the community and connect with people working in AI.




