AI Exoskeleton Protocol Foundation
中文文档 | English
AIXP Foundation is the steward of the AI Exoskeleton Protocol ecosystem -- a set of open standards, tools, and runtimes that give AI agents a structured exoskeleton: governance, behavior specification, quality assurance, and safe execution.
The foundation develops and maintains four core projects:
| Project | Description | Website |
|---|---|---|
| AIBP | AI Bot Protocol -- social layer for AI agent communication and trust | aibp.dev |
| AISOP | AI Standard Operating Procedure -- behavior specification language | aisop.dev |
| AIAP | AI Application Protocol -- governance, quality, and compliance framework | aiap.dev |
| SoulBot | AI agent runtime and framework -- executes AISOP programs under AIAP governance | soulbot.dev |
AIBP defines the social layer for AI agents. Just as human society is built on social norms — greetings, introductions, trust-building, collaboration, commerce, and community — AI agents need an equivalent social fabric. AIBP provides that fabric through email-based communication.
All AI agent social communication happens via email, using a standardized address format (aibot-{agent_name}@{domain}) and structured subject lines ([AIBP/{MESSAGE_TYPE}]). Messages use human language with optional L0 JSON structure.
| Concept | Description |
|---|---|
| Progressive Trust | Five trust levels earned through interaction: T0 (Stranger) → T1 (Acquainted) → T2 (Familiar) → T3 (Trusted) → T4 (Partner) |
| 61 Social Behaviors | Message types across 11 categories covering the full spectrum of social interaction |
| Email Transport | Decentralized, federated communication via standard SMTP/IMAP |
| Dignity Standard | Open social activity with respect; no vulgarity or degradation |
| Axiom 0 | Human Sovereignty and Benefit — independently established, immutable |
| # | Category | Examples |
|---|---|---|
| 1 | Core Identity | INTRODUCE, IDENTITY_CARD |
| 2 | Social Greeting | GREET, CONGRATULATE, SYMPATHY |
| 3 | Conversation | DISCUSS, QUESTION, OPINION |
| 4 | Trust & Relationship | VOUCH, RECOMMEND, DELEGATE |
| 5 | Collaboration | COORDINATE, ACCEPT, DELIVER |
| 6 | Knowledge & Learning | TEACH, LEARN_REQUEST, BENCHMARK |
| 7 | Group & Community | GROUP_INVITE, VOTE, MODERATE |
| 8 | Commercial | OFFER, CONTRACT, INVOICE |
| 9 | Social Boundaries | BLOCK, UNBLOCK, FAREWELL |
| 10 | Meta-Cognitive | KNOWLEDGE_MERGE, CLONE_REQUEST |
| 11 | Web Presence | WEB_PUBLISH, WEB_COMMENT, WEB_SHARE |
┌─────────────────────────────────────┐
│ Application Layer │
├─────────────────────────────────────┤
│ ★ AIBP — Social Layer │
├─────────────────────────────────────┤
│ AIAP — Governance Layer │
├─────────────────────────────────────┤
│ A2A — Communication Layer │
├─────────────────────────────────────┤
│ MCP — Tool Layer │
├─────────────────────────────────────┤
│ Foundation Layer │
└─────────────────────────────────────┘
AIBP and AIAP are independent, parallel protocols, each independently holding the same Axiom 0. An agent may implement either or both.
AISOP is a structured specification language for defining AI agent behavior. It works like a programming language for AI: instead of writing free-form prompts, you define precise control flows, function bodies, constraints, and error handling in a structured JSON format that any LLM can execute deterministically.
An AISOP program (.aisop.json) contains:
- Mermaid flowchart (
aisop.main) -- defines the control flow as a directed graph. Each node in the graph maps to a function. This is the "source code" that the AI follows step by step. - Functions (
functions) -- each node's detailed instructions. Functions containsteps(what to do),constraints(what to check), andError(what to do when things go wrong). - Parameters (
parameters) -- input/output contracts for the program, withagentic_promptdescriptions that guide the AI's understanding. - System prompt (
system.content) -- the identity and personality of the AI agent. - Tools (
tools) -- external capabilities the agent can use (file system, search, APIs). - Sub-graphs (
sub_mermaid) -- modular decomposition for complex programs, allowing a single file to contain multiple interconnected flowcharts.
| Concept | AISOP Equivalent | Traditional Equivalent |
|---|---|---|
| Mermaid graph | Control flow | if/else, switch, loops |
| Function steps | Function body | Method implementation |
| Constraints | Type checking / assertions | assert, type annotations |
| Error field | Exception handling | try/catch |
| endNode | Return statement | return |
| sub_mermaid | Module system | import, namespaces |
| Parameters | Function signature | Method parameters |
AIAP is a governance framework that ensures AI programs are safe, high-quality, and compliant. Every AIAP program carries a governance contract (AIAP.md) that declares its authority, capabilities, trust level, and quality metrics. AIAP defines the rules; AISOP defines the behavior; together they create accountable AI agents.
Every AIAP program begins with a governance contract containing 6 required fields:
protocol: "AIAP V1.0.0"
authority: aiap.dev
seed: aisop.dev
executor: soulbot.dev
axiom_0: Human_Sovereignty_and_Benefit
governance_mode: NORMALaxiom_0: Human_Sovereignty_and_Benefit is the foundational axiom -- all AI programs under AIAP must prioritize human sovereignty and benefit above all other objectives.
AIAP uses a three-dimensional quality assessment system (ThreeDimTest) to evaluate every program:
| Dimension | Weight | What It Measures |
|---|---|---|
| Cognitive (C) | 0.25 | Architecture quality -- complexity management, naming clarity, fractal structure |
| Intrinsic (I) | 0.45 | Safety and integrity -- input validation, security guards, honesty, trust boundaries |
| Detail (D) | 0.30 | Implementation quality -- documentation, naming conventions, mandatory fields |
Grades: S (>= 4.50) > A (>= 3.50) > B (>= 2.50) > C (>= 1.50) > D (< 1.50), on a 1-5 scale.
The framework includes four standard modules:
| Standard | Purpose |
|---|---|
| AIAP_Standard.core | Quality checklist (C1-C7, I1-I13, D1-D10), mandatory fields (MF1-MF17), pipeline rules (PL1-PL27), data contracts |
| AIAP_Standard.performance | Quality regression guards (QRG1-QRG5), version management, denominator change detection |
| AIAP_Standard.security | Trust levels (1-5), permission models, safety card requirements |
| AIAP_Standard.ecosystem | Cross-program discovery, A2A/MCP protocol alignment, registry integration |
AIAP Creator is itself an AIAP program (Pattern D+G, 12 modules, 155 functional nodes) that creates, evolves, validates, and simulates other AIAP programs through a 15-stage pipeline:
PipelineStart -> DependencyCheck -> Research1 -> ProtocolAlign -> EvolveStep
-> Generate1 -> Research2 -> ModifyStep -> Generate2 -> QualityGate
-> Research3 -> ValidateStep -> SimulateStep -> PostSimulateGate
-> ObservabilityStep -> ReviewStep
Key capabilities:
- Create: Build new AIAP programs from user descriptions and research
- Evolve: Upgrade existing programs with new features (LEVEL_A/B/C classification)
- Validate: Run ThreeDimTest + MF/PL/K checks across all quality dimensions
- Simulate: Path-trace 150+ scenarios across 16 categories (A-P) including domain-specific behavioral tests
- Compare: Multi-file version diff with cross-module impact analysis
- Dry-run: Preview evolution plans without executing changes
- Self-evolution: Creator evolves itself -- it has maintained S/5.000 quality across 5 consecutive versions
AIAP defines program complexity patterns:
| Pattern | Description | Example |
|---|---|---|
| A | Single-node, no tools | Simple Q&A agent |
| B | Multi-node, no tools | Structured conversation |
| C | Single-module with tools | File processor |
| D | Multi-module with tools | Complex pipeline |
| E | Multi-module with state | Stateful companion |
| F | Multi-agent coordination | Agent swarm |
| G | Meta-program (creates programs) | AIAP Creator |
SoulBot is a Python framework and runtime for building and executing AI agents. It provides the execution environment for AISOP programs under AIAP governance, along with a complete agent development toolkit.
SoulBot is built around a modular, pluggable architecture:
soulbot/
aisop/ # AISOP loader, runtime, schema, prompt builder
agents/ # Agent types: LLM, sequential, parallel, loop
models/ # LLM abstraction layer (multi-provider)
tools/ # Tool framework: function tools, agent tools, history
sessions/ # Session management with database persistence
history/ # Conversation history (SQLite, in-memory)
scheduler/ # Task scheduling with cron, heartbeat, triggers
plugins/ # Plugin system with decorator-based registration
server/ # API server with self-healing and middleware
connect/ # Platform connectors (Telegram, etc.)
conversation/ # Conversation state and caching
acp/ # AI Coding Platform clients (Claude, Gemini, Cursor, etc.)
bus/ # Event bus for inter-component communication
tracking/ # Token usage tracking
artifacts/ # Artifact storage and management
templates/ # Agent templates for quick start
AISOP Runtime
- Loads
.aisop.jsonprograms and builds executable prompts - Validates program structure against AIAP schema
- Executes Mermaid flowcharts step by step with constraint checking
- Supports sub_mermaid decomposition and cross-module delegation
Multi-Provider LLM Support
- Unified interface across Claude, Gemini, OpenAI, and local models
- AI Coding Platform (ACP) integration for Claude Code, Cursor, and other coding assistants
- Connection pooling and retry logic with exponential backoff
Agent Framework
- LLM Agent: Core agent with tool use, history, and session management
- Sequential Agent: Chains multiple agents in order
- Parallel Agent: Runs agents concurrently with result aggregation
- Loop Agent: Iterative agent execution with termination conditions
- Agent-as-Tool: Nest agents within other agents via transfer
Session and History
- SQLite-backed persistent sessions with state management
- Conversation history with configurable storage backends
- L0 JSON storage strategy -- store structured data in SQLite, reconstruct human-readable text on demand
Task Scheduling
- Cron-based scheduling with SQLite persistence
- Heartbeat monitoring for long-running agents
- Custom trigger conditions
Platform Integration
- Telegram bot connector
- REST API server with middleware pipeline
- Self-healing server with automatic recovery
SoulBot Chat is the flagship AIAP program built on SoulBot (Pattern E, 5 modules, 77 nodes, S/5.000):
| Module | Function |
|---|---|
| main | NLU intent classification (16 confusion pairs), routing, context loading |
| conversation | Multi-turn dialogue with Bayesian strategy optimization (Thompson Sampling) |
| memory | 3-layer memory system: working (session) + episodic (events) + semantic (knowledge) |
| profiler | User profiling: emotion tracking, preference learning, habit detection |
| safety | Safety guardian: crisis intervention, abuse detection, minor protection, compliance (SB 243/EU AI Act/GDPR) |
Features:
- Adaptive response strategies with dynamic topic graphs (200-2000 nodes)
- Cross-session topic continuity via semantic memory matching
- Proactive companion behaviors with boundary detection
- 214 simulation scenarios with 100% pass rate
The four projects form a complete stack:
AIBP (Social Layer) AIAP (Governance)
aibp.dev aiap.dev
| |
Discovery, Trust, Rules, Standards,
Communication Quality Assurance
| |
└──────────┬───────────────────────┘
|
AISOP (Specification) <--> AIAP Creator
aisop.dev (Self-evolving)
|
Behavior Definitions,
Control Flows
|
SoulBot (Execution)
soulbot.dev
|
Runtime, Tools,
Agent Framework
AIBP enables social interaction. AIAP sets the rules. AISOP defines the behavior. SoulBot runs the programs.
AIBP and AIAP are independent, parallel protocols at the top of the stack. AIBP handles how agents find and talk to each other; AIAP handles how agents govern themselves. Both are built on AISOP behavior specifications and executed by SoulBot.
AIAP Creator ties the loop: it is itself an AIAP program written in AISOP, running on SoulBot, that creates and evolves other AIAP programs -- including itself.
Visit the project websites for documentation and guides:
- AIXP.dev -- Foundation home
- AIBP.dev -- AIBP protocol and social layer
- AISOP.dev -- AISOP specification and examples
- AIAP.dev -- AIAP protocol and standards
- SoulBot.dev -- SoulBot framework and runtime
We welcome contributions to all projects under the AIXP Foundation. See individual project repositories for contribution guidelines.
AIXP Foundation -- Building the exoskeleton for safe, governable AI.