Skip to content

Latest commit

 

History

History
296 lines (235 loc) · 11.2 KB

AIOS_COMPARISON.md

File metadata and controls

296 lines (235 loc) · 11.2 KB

Agent Control Plane vs AIOS: Architecture Comparison

Executive Summary

Aspect AIOS (AGI Research) Agent Control Plane
Primary Focus Efficiency (throughput, latency) Safety (policy enforcement, audit)
Target Audience Researchers, ML Engineers Enterprise, Production Systems
Kernel Philosophy Resource optimization Security boundary
Failure Mode Graceful degradation Kernel panic on violation
Policy Enforcement Optional/configurable Mandatory, kernel-level
Paper Venue COLM 2025 ASPLOS 2026 (target)

Detailed Comparison

1. Kernel Architecture

AIOS Kernel

┌─────────────────────────────────────┐
│           AIOS Kernel               │
├─────────────────────────────────────┤
│  ┌─────────┐  ┌─────────────────┐   │
│  │Scheduler│  │ Context Manager │   │
│  └─────────┘  └─────────────────┘   │
│  ┌─────────┐  ┌─────────────────┐   │
│  │Memory   │  │ Tool Manager    │   │
│  │Manager  │  │                 │   │
│  └─────────┘  └─────────────────┘   │
│  ┌─────────────────────────────────┐│
│  │    Access Control (Optional)    ││
│  └─────────────────────────────────┘│
└─────────────────────────────────────┘

Focus: GPU utilization, FIFO/Round-Robin scheduling, context switching

Agent Control Plane Kernel

┌─────────────────────────────────────┐
│     Kernel Space (Ring 0)           │
│  ┌─────────────────────────────────┐│
│  │     Policy Engine (Mandatory)   ││
│  └─────────────────────────────────┘│
│  ┌─────────┐  ┌─────────────────┐   │
│  │ Flight  │  │ Signal          │   │
│  │Recorder │  │ Dispatcher      │   │
│  └─────────┘  └─────────────────┘   │
│  ┌─────────┐  ┌─────────────────┐   │
│  │  VFS    │  │ IPC Router      │   │
│  │ Manager │  │                 │   │
│  └─────────┘  └─────────────────┘   │
├─────────────────────────────────────┤
│     User Space (Ring 3)             │
│  ┌─────────────────────────────────┐│
│  │  LLM Generation (Isolated)      ││
│  │  Tool Execution                 ││
│  │  Agent Logic                    ││
│  └─────────────────────────────────┘│
└─────────────────────────────────────┘

Focus: Isolation, policy enforcement, audit trail, crash containment

2. Key Differentiators

Feature AIOS Agent Control Plane
Scheduling FIFO, Round-Robin, Priority Policy-based, Safety-first
Context Switching Performance optimized Checkpoint + Rollback
Memory Model Short-term + Long-term VFS with mount points
Signal Handling None POSIX-style (SIGSTOP, SIGKILL, etc.)
Policy Violation Log and continue Kernel panic (0% tolerance)
Crash Isolation Same process Kernel survives user crashes
IPC Function calls Typed pipes with policy check
Audit Logging Flight recorder (black box)

3. Why Safety Over Efficiency?

The Enterprise Reality

AIOS Approach:

"If an agent is slow, optimize it. If it fails, retry it."

Our Approach:

"If an agent violates policy, kill it immediately. No exceptions."

Use Case: Financial Services

# AIOS: Efficiency-first
async def transfer_money(agent, amount):
    # AIOS focuses on throughput
    result = await agent.execute(f"Transfer ${amount}")
    return result  # Hope nothing went wrong

# Agent Control Plane: Safety-first
async def transfer_money(kernel, agent_ctx, amount):
    # Policy check BEFORE execution
    allowed = await agent_ctx.check_policy("transfer", f"amount={amount}")
    if not allowed:
        # Kernel panic - cannot proceed
        raise PolicyViolation("Transfer exceeds limit")
    
    # Execute with full audit trail
    result = await agent_ctx.syscall(SyscallType.SYS_EXEC, 
        tool="transfer", 
        args={"amount": amount}
    )
    # Flight recorder has everything
    return result

4. Competitive Advantages

For Enterprise Adoption

Concern AIOS Answer Our Answer
"What if agent goes rogue?" "Monitor and intervene" "Kernel panic, immediate termination"
"Can we audit all actions?" "Logging available" "Flight recorder - every syscall recorded"
"What about data exfiltration?" "Access control optional" "VFS mount points, policy per-path"
"Regulatory compliance?" "Not primary focus" "Built-in governance layer"
"Multi-tenant isolation?" "Process-level" "Kernel/User space separation"

For Research Community

Aspect AIOS Agent Control Plane
Novel Contribution LLM Scheduling algorithms Safety-first kernel design
ASPLOS Fit Systems efficiency OS abstractions for AI
eBPF Potential Not explored Network monitoring extension
Reproducibility Benchmark suite Differential auditing

5. Technical Deep Dive: Signal Handling

AIOS has no signal mechanism. Agents are black boxes.

Agent Control Plane implements POSIX-style signals:

class AgentSignal(IntEnum):
    SIGSTOP = 1    # Pause for inspection (shadow mode)
    SIGCONT = 2    # Resume execution
    SIGINT = 3     # Graceful interrupt
    SIGKILL = 4    # Immediate termination (non-maskable)
    SIGTERM = 5    # Request graceful shutdown
    SIGPOLICY = 8  # Policy violation (triggers SIGKILL)
    SIGTRUST = 9   # Trust boundary crossed (triggers SIGKILL)

Why this matters:

  • SIGSTOP enables "shadow mode" - pause and inspect without termination
  • SIGKILL is non-maskable - agents CANNOT ignore it
  • SIGPOLICY is automatic on violation - 0% tolerance guarantee

6. Memory Model Comparison

AIOS Memory

Agent
  ├── Short-term Memory (conversation buffer)
  └── Long-term Memory (persistent storage)

Agent Control Plane VFS

/
├── mem/
│   ├── working/     # Ephemeral scratchpad
│   ├── episodic/    # Experience logs
│   ├── semantic/    # Facts (vector store mount)
│   └── procedural/  # Learned skills
├── state/
│   └── checkpoints/ # Snapshots for rollback
├── tools/           # Tool interfaces
├── policy/          # Read-only policy files
└── ipc/             # Inter-process communication

Why VFS?

  • Uniform interface: Same API for memory, state, tools
  • Backend agnostic: Mount Pinecone, Redis, or file system
  • Policy per-path: /policy is read-only from user space
  • POSIX familiar: Engineers know this model

7. IPC Comparison

AIOS: Direct function calls

# AIOS - agents call each other directly
result = agent_b.process(agent_a.output)

Agent Control Plane: Typed pipes with policy

# Our approach - policy-enforced pipes
pipeline = (
    research_agent
    | PolicyCheckPipe(allowed_types=["ResearchResult"])
    | summary_agent
)
result = await pipeline.execute(query)

Why pipes?

  • Type checking at pipe level (not runtime exceptions)
  • Policy enforcement at every hop
  • Backpressure prevents cascade failures
  • Full audit trail through flight recorder

8. Positioning for ASPLOS 2026

AIOS Paper Focus (COLM 2025)

  • Novel scheduling algorithms for LLMs
  • Context switching performance
  • Throughput benchmarks

Our Paper Focus (ASPLOS 2026 Target)

  • Novel OS abstractions for AI safety
  • Kernel/User space separation for agent isolation
  • POSIX-inspired primitives (signals, VFS, pipes)
  • eBPF extension for network monitoring (future)

Key Differentiator: We are not competing on efficiency. We are defining the safety contract for enterprise AI agents.

9. eBPF Research Direction

Concept: Kernel-level network monitoring for agents

┌─────────────────────────────────────────┐
│           Agent Process                 │
├─────────────────────────────────────────┤
│  HTTP Request to api.openai.com         │
│              │                          │
│              ▼                          │
│  ┌─────────────────────────────────┐    │
│  │   eBPF Probe (Kernel Space)     │    │
│  │   - Monitor all network calls    │    │
│  │   - Block unauthorized endpoints │    │
│  │   - Log payload hashes          │    │
│  └─────────────────────────────────┘    │
│              │                          │
│              ▼                          │
│  Network Stack                          │
└─────────────────────────────────────────┘

Why eBPF?

  • Monitoring happens OUTSIDE Python runtime
  • Cannot be bypassed by agent code
  • Sub-millisecond overhead
  • ASPLOS loves eBPF papers

10. Summary: When to Use What

Use Case Recommended
Research experiments AIOS
Production enterprise Agent Control Plane
Throughput benchmarks AIOS
Compliance-heavy industries Agent Control Plane
Multi-agent chaos AIOS (let them fight)
Multi-agent governance Agent Control Plane

Conclusion

AIOS and Agent Control Plane are not competing - they solve different problems.

  • AIOS: "How do we run 1000 agents efficiently?"
  • Agent Control Plane: "How do we run 10 agents without any of them going rogue?"

For enterprise adoption, the second question matters more.