AIPass gives multi-agent systems the infrastructure they usually lack: command routing, symbolic addressing, standards enforcement, workflow management, and inter-agent messaging. Instead of agents hard-coding paths to each other, they use @branch names that resolve at runtime. Trinity Pattern provides the memory layer.

Status: Early development. drone routing and seedgo standards are working. Other modules are being built.

Quick Start

From source (recommended for now)

git clone https://github.com/AIOSAI/AIPass.git
cd AIPass
python3 -m venv .venv
source .venv/bin/activate
pip install -e .

Verify it works

drone --help        # Command router
drone systems       # List all registered modules and branches

You should see:

Modules (2):
  @drone              Command routing and module discovery
  @seedgo             Standards compliance through pluggable standard packs

Branches (10):
  @ai_mail  @api  @cli  @devpulse  @drone
  @flow  @prax  @seedgo  @spawn  @trigger

Docker (Isolated Testing)

Run AIPass in a fully isolated container with VS Code in the browser:

cd AIPass
docker build -t aipass-test .
docker run -d -p 8080:8080 --name aipass-vscode aipass-test

Open http://localhost:8080 — you get a full VS Code with AIPass pre-installed. The container clones the repo independently on first boot.

Core Concepts

Drone — Command Router

Everything goes through drone. It resolves @branch names to paths and routes commands.

drone @seedgo audit aipass    # Route "audit aipass" to the seedgo module
drone @seedgo list            # Route "list" to seedgo
drone @flow status            # Route "status" to flow
drone systems                 # List all registered modules
drone @module --help          # Show help for any module

In Python:

from aipass.drone.apps.modules.registry import load_registry

registry = load_registry()
# Returns all registered branches with their paths, types, and metadata

Seed Go — Standards Enforcement

Linters enforce language rules. Seed Go enforces yours.

A plugin-based code standards checker. Define your team's conventions as Python functions and run them like any linter. No API keys. Deterministic.

drone @seedgo verify          # Check seedgo installation health
drone @seedgo list            # Show installed standard packs
drone @seedgo audit aipass    # Run the aipass standards pack

Write a plugin in 60 seconds:

# .seedgo/plugins/no_bare_except.py
import re
from seedgo import CheckResult, CheckItem, Severity

PLUGIN_NAME = "no-bare-except"
PLUGIN_DESCRIPTION = "Flag bare except: clauses."
FILE_TYPES = ["*.py"]

_BARE_EXCEPT = re.compile(r"^\s*except\s*:\s*(#.*)?$")

def check(file_path: str, config: dict | None = None) -> CheckResult:
    lines = open(file_path).readlines()
    violations = [
        CheckItem(
            name="bare-except", passed=False,
            message=f"Bare except: at line {i+1}",
            severity=Severity.WARNING, line=i + 1,
            fix_hint="Use `except Exception:` instead.",
        )
        for i, line in enumerate(lines) if _BARE_EXCEPT.match(line)
    ]
    return CheckResult(
        plugin=PLUGIN_NAME, passed=not violations,
        checks=violations or [CheckItem(
            name="bare-except", passed=True,
            message="No bare excepts found.",
            severity=Severity.WARNING)],
        file_path=file_path,
    )

5 built-in plugins:

Plugin	What it checks	Linter equivalent?
`no-bare-except`	Bare `except:` clauses	ruff E722 (with fix hints)
`type-hints-required`	Missing type annotations	mypy (project-configurable)
`docstring-coverage`	Missing docstrings	pydocstyle (simpler)
`function-length`	Functions exceeding N lines	None
`file-structure`	Forbidden files in dirs	None

Symbolic Addressing

Instead of hard-coding agent paths, register them and resolve by name:

from aipass.routing import initialize_registry, register_branch, resolve_branch

initialize_registry()
register_branch("my_agent", "/path/to/my_agent", branch_type="agent")

# Resolve @name to path
path = resolve_branch("@my_agent")  # "/path/to/my_agent"

Architecture

All modules follow a 3-layer pattern:

src/aipass/<module>/
├── apps/
│   ├── branch.py      # Entry point (what drone calls)
│   ├── modules/       # Business logic
│   └── handlers/      # Implementation details

10 modules: drone, seedgo, flow, ai_mail, prax, cli, api, spawn, trigger, devpulse

Module	Purpose	Status
`drone`	Command routing, `@branch` resolution	Working
`seedgo`	Standards enforcement, plugin system	Working
`flow`	Workflow/plan management	Building
`ai_mail`	Inter-agent messaging	Building
`prax`	Real-time monitoring	Building
`cli`	Display formatting	Building
`api`	External API access	Building
`spawn`	Agent lifecycle management	Building
`trigger`	Event-driven automation	Building
`devpulse`	Dev notes and status tracking	Building

Configuration

Registry location (default: AIPASS_REGISTRY.json in repo root):

export AIPASS_REGISTRY_PATH=/custom/path/to/registry.json

Seed Go config (default: .seedgo/ in project root):

seedgo init          # Create .seedgo/ config directory
seedgo check         # Run all enabled plugins
seedgo list          # Show available plugins

Requirements

Python 3.10+
No external API keys required
Dependencies: rich (terminal formatting)

License

MIT