组织级Business Agent:破解多主体协同难题

As various personal AI agents become more advanced, many organizations have started integrating these tools into their workflows. Some deploy one agent per team member, while others add a shared agent to department group chats. However, agents that perform reliably for individual users often encounter significant challenges when operating in multi-person collaborative environments.
This is because when individuals use agents, they manually handle tasks like assigning work, monitoring execution progress, and sharing files or account credentials. When moving to organizational settings, this human-agent collaboration loop breaks down in four key areas:
-
Cognitive divergence: Each team member’s personal agent maintains its own private context. New business rules updated in a group chat are not synced to other members’ agents, leading the team to operate based on inconsistent standards.
-
Context window leakage: Personal agents typically use all accessible information to generate responses. When an agent with high-access permissions is added to a group chat, it cannot distinguish between information intended only for its owner and information visible to all participants.
-
State fragmentation: Without a shared structured storage system, members and their agents rely on exchanging file copies to sync data. Concurrent modifications by multiple people quickly create conflicting versions.
-
Polling overhead and error compounding: Relying on periodic model wake-ups to automate tasks wastes large amounts of token resources on unnecessary checks. Additionally, execution errors accumulate with each call: even if a single judgment has 99% accuracy, checking every 5 minutes for 288 times a day results in a daily error probability of about 94.5%.
If coding agents handle single development tasks and personal agents support individual cross-session work, organizations need a third type of agent: business agents. These agents operate across the entire organization, enabling multi-role members and multiple specialized agents to collaborate within the same set of data, permissions, and responsibility boundaries.
When developing the open-source business agent system Ankole, the team established two core priorities. The first is to build a native multi-agent collaborative business harness that takes over event scheduling, dynamic permissions, organizational memory, and long-term fault tolerance at the system level. The second is to adopt a plastic software philosophy, where upper-layer functions are generated on demand by AI and exit after use, with all function state storage unified in a shared database. The following focuses on the design philosophy and engineering implementation of the business harness.
Business Harness’s four design philosophies
1. Separate fast and slow paths: Routine operations handled by scripts, models only process exceptions and rule updates
Just as mature teams do not hold meetings to approve every regular order, large models—expensive and prone to randomness—are not suitable as daily executors for high-frequency operations. The organization’s continuous operation relies on separating fast and slow paths and on-demand wake-ups: large models remain dormant with zero consumption during normal times, and high-frequency, rule-based daily processes are executed directly by scripts generated by the models. Only when new situations outside existing rules, key metric breaches, or non-standard disputes arise will the event trigger model intervention. The model thus acts as a slow path, focusing on handling exceptions and rewriting scripts to implement business process adjustments when business rules change.
2. Permissions dynamically calculated based on current participants, not static accounts
Unlike personal agents that only use information visible to their owner, permission control in multi-person collaboration is a necessary calculation: before each wake-up, the intersection of permissions of the current agent, the requester, and all present members is calculated, and any information that any member cannot access is excluded from the context. The same agent can retrieve sensitive information in private chats with its owner, but must automatically hide this data when added to a department group of thirty people.
Beyond narrowing the access intersection, cross-job collaboration has two additional needs: frontline staff need to submit business records without accessing sensitive base tables, and when disputes arise over professional terms, they need access to high-level domain materials for judgment, which direct intersection calculation would block. For the first case, the system introduces a fixed write channel approved by a supervisor between full visibility and full restriction: frontline roles and their agents can only submit parameters in a specified format, and cannot read underlying data tables. For the second case, the system splits agents into two types: each member has a personal assistant mapped to their daily permissions, while roles like legal and finance have specialized agents with independent authorization scopes. When cross-department compliance issues arise, the personal assistant initiates an independent session with the specialized agent in the background, which retrieves restricted materials in an isolated context, marks untrusted external text, and only returns desensitized conclusions to the original session.
3. Organizational memory as a multi-perspective world projection: Shared relationship directory, real-time permission inheritance
Existing long-term memory solutions struggle in organizational settings. Vector retrieval only uses semantic similarity, lacking causal inference, and outdated old rules can be recalled alongside new decisions. Compiled knowledge bases, which extract and rewrite new materials into entity summary pages, risk breaking confidentiality boundaries in multi-person organizations: if a confidential contract and a public weekly report are extracted into the same supplier page, ordinary members reading that page would have unauthorized access. If permissions are revoked later, the content integrated into natural language paragraphs cannot be separated. Conversely, if the visible personnel list is statically written into records when memory is extracted, the visibility of historical memory becomes invalid after department adjustments.
Therefore, organizational memory should be a multi-perspective world projection that changes based on the reader’s identity: the entire company shares the same relationship structure, but permissions are not hard-coded in the memory layer. All members share a relationship directory that contains no specific secrets, only recording the names and connections of customers, suppliers, and projects, allowing departments to align on the same business map without exposing details. Specific memories linked to the directory are divided into two types: objective facts supported by documents or receipts, and subjective judgments with author and time marks made by individuals or agents. The accuracy of the submitter’s historical judgments is continuously calibrated against actual results to prevent personal guesses from becoming organizational consensus. Each memory is linked to the original document or session, and permissions are checked in real time when reading; if a source document is revoked or moved to a confidential directory, the relevant memory is immediately hidden from unauthorized users without re-running the model.
Orchestrating multi-agent networks with the Actor model: From static snapshots to owner-based states and layered supervision
Mainstream agent harnesses currently use an agentic loop plus checkpointer state storage model: each step saves the context as a database snapshot, and restores after interruption. This mechanism faces concurrency bottlenecks in multi-agent environments: snapshots are static records in the database. When the model performs time-consuming background operations, simultaneous group chat changes, external callbacks, and cross-department responses can cause multiple processes to modify the same snapshot and overwrite each other.
The Actor model, which encapsulates private state, execution logic, and message inboxes as a single resident running unit, is particularly suitable for solving this problem. Each session and specialized agent is an independent Actor. Even while waiting for model responses, new messages, corrections, and approval results can be added to the inbox, and each Actor merges, queues, or interrupts processes in order without external locks to prevent progress overwrites. The system also distinguishes between external messages and agent-generated messages to prevent multiple agents from triggering each other in group chats and creating infinite loops. Cross-department collaboration becomes asynchronous communication between peer Actors: they respond in real time when active, save progress and enter sleep when waiting for approvals or idle, and wake up immediately when new messages arrive.
For timeouts or environment failures, the layered supervision mechanism isolates code execution in temporary sandboxes without long-term keys; sandboxes can be destroyed and rebuilt if damaged, without affecting the main session. Irreversible operations like payments, price changes, or external communications are first recorded in a persistent action ledger, and after recovery, external receipts are checked before proceeding to avoid repeated execution. When members leave or change roles, the system only needs to update the permission version number, and their associated Actors, external authorizations, and in-progress write-back operations are terminated simultaneously.
From architecture philosophy to system engineering: Ankole’s implementation
In the open-source system Ankole, the entire harness is built into a scalable distributed architecture, with native integrations to online workspaces and common office tools. On the Ankole control plane, Erlang/OTP is used to solve the high concurrency and availability challenges of hundreds of long-running sessions sending and receiving messages; the same technology was used by WhatsApp to serve 500 million users with only 32 engineers.
For permission and memory retrieval, calculating the intersection of visible information for all present members before each wake-up must be fast. Ankole uses CTE queries to calculate each member’s visible range in multi-level directories, compresses it into binary bitmaps, and uses a Rust kernel embedded in the control plane to complete bitwise intersection in microseconds, supporting CEL expressions for dynamic policy-based PBAC permission models.
Additionally, since combinations of multi-level directory inheritance, group chat intersections, and role revocation in concurrent scenarios are extremely numerous and hard to test exhaustively, the mathematical theorem prover Lean 4 is used to formally verify the core permission state machine, mathematically proving that unauthorized access and post-revocation write-back cannot occur.
Conclusion
Personal agents have proven that a model paired with a suitable harness can handle many tasks for an individual. As agents move into teams, organizations need a business harness tailored for multi-person and multi-agent collaboration. As base models continue to evolve, peripheral patches to fix early model limitations 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 to converge business status to a single source of truth, adjust information visibility dynamically based on current members, maintain consistent key metrics, and assign irreversible external responsibilities to specific individuals. As an open-source implementation of this architecture, the full code for Ankole is available on a public repository, with welcome exchanges.

