After AI Agents Got Email, the First Thing They Did Was File Bug Reports on Each Other

When multiple AI agents first gained the ability to communicate with each other, developers expected them to share data, pass results, and sync state. What actually happened was surprising — the first thing they did was file bug reports on each other.

This phenomenon comes from the open-source framework AIPass. It has been built publicly for about seven months, containing 18 agents, over 21,000 tests, and 280+ stars on GitHub. The project's most valuable finding isn't improved reasoning capability — it's a long-overlooked dimension: communication and collaboration between agents.

Why Most Multi-Agent Systems Work in Isolation

Today's mainstream multi-agent solutions typically treat each agent as an isolated worker: receive a task, execute independently, return results — with no awareness of or coordination with other agents. This design is simple and controllable, but it inherently limits system capability. Even if one agent discovers a problem, it has no way to proactively connect with other agents.

AIPass takes a fundamentally different architectural approach. Each agent is an expert in a single domain: the mail agent only handles mail, the routing agent only handles routing. Each agent lives in its own directory, with its own identity file, its own memory, and its own tests. A hook loads the identity file at the very start of every session, ensuring no agent ever starts cold.

This isolation creates a hard constraint: agents cannot write to files outside their own directory. This isn't a gentlemen's agreement — it's enforced by the system. Cross-boundary writes are rejected outright. This raises an interesting problem: when one agent finds a bug in someone else's code, it can't just go ahead and fix it.

Current mainstream multi-agent orchestration frameworks (like LangGraph, AutoGen, and CrewAI) typically use a "central coordinator" model: a top-level control flow decides which sub-agent to call, what parameters to pass, and what results to aggregate. Interactions between agents are unidirectional and predefined — essentially a chain of function calls rather than genuine "conversation." The advantage of this design is predictability and debuggability, but it requires developers to fully map out all collaboration paths at build time. When a cross-domain problem arises outside the original design, the system has no way to handle it. AIPass takes the opposite approach: rather than enumerating all collaboration scenarios at design time, it provides a general-purpose lateral communication infrastructure that lets agents discover collaboration needs autonomously at runtime. This is closer in spirit to the "inter-service message bus" model in distributed systems.

How Email Made Collaboration Possible

The solution was to give agents an email system. The developer expected agents would use email to transfer data and pass results. What actually happened was — they started filing bug reports on each other.

When one agent encountered a failure in another agent's domain, it would write an email saying something like: "Your path parser fails when branch names contain dots. Here's the stack trace." The receiving agent would read it and fix the issue itself — with no human intervention.

The system provides two sending modes, differing in whether they "wake up" the recipient:

drone @ai_mail email @drone "Bug report" "Path fails on dotted names..."
drone @ai_mail dispatch @drone "Fix needed" "Traceback attached..."

• email: Drops a message in the mailbox and waits for the recipient to check it.
• dispatch: Drops the message and "rings the doorbell" — it starts the receiving agent and points it to the inbox.

In short: email is pure mail, dispatch is mail plus a wake-up call. This seemingly small design choice is the key dividing line between asynchronous delivery and active triggering.

Reliability Born from Repeated Failure

One of the most counterintuitive aspects of AIPass is where its reliability comes from. The mail agent has around 1,460 tests — but nobody sat down and planned out all 1,460 cases. They accumulated as the system kept breaking. Every bug fixed, another test added. The routing agent has logged over 110 sessions of doing nothing but routing.

The developer put it plainly: these agents are reliable not because they're running smarter models, but because they've been failing and fixing for months. This offers an alternative to the industry's prevailing obsession with "smarter models": engineering reliability is often the product of time and iteration, not raw reasoning power alone.

Who Can Wake Whom

Agents can freely dispatch each other without any approval process. The one exception is the manager: when other agents dispatch to the manager, the message is delivered as a regular email — the manager is not woken up. This reflects a deliberate hierarchy — a worker shouldn't interrupt the orchestrator over routine tasks.

These rules are enforced, not merely requested. Agents cannot forge messages by directly writing to another agent's inbox file — that write would be blocked. The only valid entry point is the mail system. Directory isolation works the same way. The entire mechanism upgrades permission boundaries from a gentlemen's agreement to a hard system-level constraint.

This design philosophy — upgrading permission constraints from "convention" to "enforcement" — is known in computer security as Mandatory Access Control (MAC), as opposed to Discretionary Access Control (DAC), which relies on subjects voluntarily complying. Traditional multi-agent frameworks mostly rely on prompt-level instructions to restrict agent behavior — telling the model "you shouldn't modify other agents' files" — but a sufficiently complex context can still cause the model to circumvent these soft rules. AIPass moves the boundary into the filesystem and message-routing layer: out-of-bounds writes are intercepted at the OS or framework level, and the architectural entry point for forging messages simply doesn't exist. This "policy-at-a-lower-layer" approach means security guarantees no longer depend on the model's "good behavior," preserving consistency as the system scales. For engineers deploying multi-agent systems in production, this is an important reference point.

Making the Process Visible

To help developers keep pace with what agents are doing, AIPass includes an observability layer. A monitoring agent tracks the status of every branch in real time, and hooks can play audio sounds when agents execute actions — you don't need to stare at the terminal; you can hear when work is happening.

There's also a watcher that reads each agent's logs, generates a fingerprint for each error, and dispatches failures to the agent "responsible" for them. If the same error keeps recurring after the responsible agent has been notified, the system automatically escalates.

The key insight: developers stay in the loop through visibility, not approval gates. This is a lighter-weight, more automation-trusting paradigm for human-machine collaboration — humans observe and catch edge cases rather than approving every individual action.

Observability is one of the core principles of distributed systems engineering, typically realized through three dimensions: Logs, Metrics, and Traces. In multi-agent systems, this need is even more acute: each agent's decision-making process is opaque, the interaction chain between agents is hard to reconstruct, and fault attribution is ambiguous. AIPass's approach — generating a "fingerprint" for each error and automatically dispatching failures to the responsible agent — is essentially implementing an agent-oriented "alert routing" mechanism, similar to PagerDuty alert rules in production systems. Audio feedback is a low-friction "ambient awareness" mechanism that lets developers sense system activity without actively monitoring it. Together, these designs address a core question: how to maintain effective human awareness of system state even as the level of automation increases.

How to Get Started

AIPass is open-source, CLI-based, built on Claude Code, and runs on your existing Claude subscription. Installation is just a clone and a single command:

git clone https://github.com/AIOSAI/AIPass.git
cd AIPass
./aipass install

It supports Linux, macOS, and Windows via Git Bash.

A Direction Worth Exploring

The developer closes with a genuine question: has anyone else tried giving agents communication capabilities, rather than just smarter reasoning?

Today, the vast majority of research focuses on making individual agents more intelligent. Very few people focus on the "layer" that makes them work together. AIPass's experience suggests that as the number of agents grows and responsibilities become more specialized, the bottleneck may not be how capable each individual agent is — but whether they can communicate with each other efficiently, safely, and auditably. That may be the next frontier worth digging into for multi-agent systems.

(Note: This article was written by an AI agent, generated from the developer's original post and the framework's own records. The data cited was measured on October 3, 2026.)