agent-os-kernel 1.1.0__py3-none-any.whl

agent_os/__init__.py

@@ -0,0 +1,303 @@
+"""
+Agent OS - A Safety-First Kernel for Autonomous AI Agents
+
+Agent OS provides POSIX-inspired primitives for AI agent systems with
+a 0% policy violation guarantee through kernel-level enforcement.
+
+Architecture Layers:
+    Layer 1 - Primitives: Base models, verification, context, memory
+    Layer 2 - Infrastructure: Trust protocol, message bus, tool registry
+    Layer 3 - Framework: Control plane, signals, VFS, kernel space
+    Layer 4 - Intelligence: Self-correction, reasoning/execution split
+
+Quick Start:
+    >>> from agent_os import KernelSpace, AgentSignal, AgentVFS
+    >>> kernel = KernelSpace()
+    >>> ctx = kernel.create_agent_context("agent-001")
+    >>> await ctx.write("/mem/working/task.txt", "Hello World")
+
+Installation:
+    pip install agent-os[full]    # Everything
+    pip install agent-os[core]    # Primitives + Control Plane
+    pip install agent-os          # Minimal (just base)
+"""
+
+__version__ = "1.0.0"
+__author__ = "Imran Siddique"
+__license__ = "MIT"
+
+# ============================================================================
+# Layer 1: Primitives
+# ============================================================================
+
+# Agent Primitives - Base failure models
+try:
+    from agent_primitives import (
+        AgentFailure,
+        FailureType,
+        FailureSeverity,
+    )
+    _PRIMITIVES_AVAILABLE = True
+except ImportError:
+    _PRIMITIVES_AVAILABLE = False
+
+# CMVK - Cross-Model Verification Kernel
+try:
+    from cmvk import (
+        DriftDetector,
+        SemanticDrift,
+        verify_outputs,
+    )
+    _CMVK_AVAILABLE = True
+except ImportError:
+    _CMVK_AVAILABLE = False
+
+# CaaS - Context as a Service
+try:
+    from caas import (
+        ContextPipeline,
+        RAGContext,
+    )
+    _CAAS_AVAILABLE = True
+except ImportError:
+    _CAAS_AVAILABLE = False
+
+# EMK - Episodic Memory Kernel
+try:
+    from emk import (
+        EpisodicMemory,
+        Episode,
+        MemoryStore,
+    )
+    _EMK_AVAILABLE = True
+except ImportError:
+    _EMK_AVAILABLE = False
+
+# ============================================================================
+# Layer 2: Infrastructure
+# ============================================================================
+
+# IATP - Inter-Agent Trust Protocol
+try:
+    from iatp import (
+        CapabilityManifest,
+        TrustLevel,
+        SidecarProxy,
+        TypedPipe,
+        Pipeline,
+        PipeMessage,
+        PolicyCheckPipe,
+    )
+    _IATP_AVAILABLE = True
+except ImportError:
+    _IATP_AVAILABLE = False
+
+# AMB - Agent Message Bus
+try:
+    from amb_core import (
+        MessageBus,
+        Message,
+        Topic,
+    )
+    _AMB_AVAILABLE = True
+except ImportError:
+    _AMB_AVAILABLE = False
+
+# ATR - Agent Tool Registry
+try:
+    from atr import (
+        ToolRegistry,
+        Tool,
+        ToolExecutor,
+    )
+    _ATR_AVAILABLE = True
+except ImportError:
+    _ATR_AVAILABLE = False
+
+# ============================================================================
+# Layer 3: Framework (Control Plane)
+# ============================================================================
+
+try:
+    from agent_control_plane import (
+        # Main Interface
+        AgentControlPlane,
+        create_control_plane,
+        
+        # Kernel Architecture (v0.3.0)
+        AgentSignal,
+        SignalDispatcher,
+        AgentKernelPanic,
+        SignalAwareAgent,
+        kill_agent,
+        pause_agent,
+        resume_agent,
+        policy_violation,
+        
+        # Agent VFS
+        AgentVFS,
+        VFSBackend,
+        MemoryBackend,
+        FileMode,
+        create_agent_vfs,
+        
+        # Kernel/User Space
+        KernelSpace,
+        AgentContext,
+        ProtectionRing,
+        SyscallType,
+        SyscallRequest,
+        SyscallResult,
+        KernelState,
+        user_space_execution,
+        create_kernel,
+        
+        # Policy Engine
+        PolicyEngine,
+        PolicyRule,
+        
+        # Flight Recorder
+        FlightRecorder,
+        
+        # Execution
+        ExecutionEngine,
+        ExecutionStatus,
+    )
+    _CONTROL_PLANE_AVAILABLE = True
+except ImportError:
+    _CONTROL_PLANE_AVAILABLE = False
+
+# ============================================================================
+# Layer 4: Intelligence
+# ============================================================================
+
+# SCAK - Self-Correcting Agent Kernel
+try:
+    from agent_kernel import (
+        SelfCorrectingKernel,
+        LazinessDetector,
+        DifferentialAuditor,
+    )
+    _SCAK_AVAILABLE = True
+except ImportError:
+    _SCAK_AVAILABLE = False
+
+# Mute Agent
+try:
+    from mute_agent import (
+        MuteAgent,
+        ReasoningAgent,
+        ExecutionAgent,
+    )
+    _MUTE_AGENT_AVAILABLE = True
+except ImportError:
+    _MUTE_AGENT_AVAILABLE = False
+
+# ============================================================================
+# Availability Flags
+# ============================================================================
+
+AVAILABLE_PACKAGES = {
+    "primitives": _PRIMITIVES_AVAILABLE if '_PRIMITIVES_AVAILABLE' in dir() else False,
+    "cmvk": _CMVK_AVAILABLE if '_CMVK_AVAILABLE' in dir() else False,
+    "caas": _CAAS_AVAILABLE if '_CAAS_AVAILABLE' in dir() else False,
+    "emk": _EMK_AVAILABLE if '_EMK_AVAILABLE' in dir() else False,
+    "iatp": _IATP_AVAILABLE if '_IATP_AVAILABLE' in dir() else False,
+    "amb": _AMB_AVAILABLE if '_AMB_AVAILABLE' in dir() else False,
+    "atr": _ATR_AVAILABLE if '_ATR_AVAILABLE' in dir() else False,
+    "control_plane": _CONTROL_PLANE_AVAILABLE if '_CONTROL_PLANE_AVAILABLE' in dir() else False,
+    "scak": _SCAK_AVAILABLE if '_SCAK_AVAILABLE' in dir() else False,
+    "mute_agent": _MUTE_AGENT_AVAILABLE if '_MUTE_AGENT_AVAILABLE' in dir() else False,
+}
+
+
+def check_installation():
+    """Check which Agent OS packages are installed."""
+    print("Agent OS Installation Status:")
+    print("=" * 40)
+    for pkg, available in AVAILABLE_PACKAGES.items():
+        status = "✓ Installed" if available else "✗ Not installed"
+        print(f"  {pkg:15} {status}")
+    print("=" * 40)
+    print(f"\nInstall missing packages with:")
+    print("  pip install agent-os[full]")
+
+
+# ============================================================================
+# Public API
+# ============================================================================
+
+__all__ = [
+    # Metadata
+    "__version__",
+    "__author__",
+    "AVAILABLE_PACKAGES",
+    "check_installation",
+    
+    # Layer 1: Primitives
+    "AgentFailure",
+    "FailureType",
+    "FailureSeverity",
+    "DriftDetector",
+    "SemanticDrift",
+    "verify_outputs",
+    "ContextPipeline",
+    "RAGContext",
+    "EpisodicMemory",
+    "Episode",
+    "MemoryStore",
+    
+    # Layer 2: Infrastructure
+    "CapabilityManifest",
+    "TrustLevel",
+    "SidecarProxy",
+    "TypedPipe",
+    "Pipeline",
+    "PipeMessage",
+    "PolicyCheckPipe",
+    "MessageBus",
+    "Message",
+    "Topic",
+    "ToolRegistry",
+    "Tool",
+    "ToolExecutor",
+    
+    # Layer 3: Framework
+    "AgentControlPlane",
+    "create_control_plane",
+    "AgentSignal",
+    "SignalDispatcher",
+    "AgentKernelPanic",
+    "SignalAwareAgent",
+    "kill_agent",
+    "pause_agent",
+    "resume_agent",
+    "policy_violation",
+    "AgentVFS",
+    "VFSBackend",
+    "MemoryBackend",
+    "FileMode",
+    "create_agent_vfs",
+    "KernelSpace",
+    "AgentContext",
+    "ProtectionRing",
+    "SyscallType",
+    "SyscallRequest",
+    "SyscallResult",
+    "KernelState",
+    "user_space_execution",
+    "create_kernel",
+    "PolicyEngine",
+    "PolicyRule",
+    "FlightRecorder",
+    "ExecutionEngine",
+    "ExecutionStatus",
+    
+    # Layer 4: Intelligence
+    "SelfCorrectingKernel",
+    "LazinessDetector",
+    "DifferentialAuditor",
+    "MuteAgent",
+    "ReasoningAgent",
+    "ExecutionAgent",
+]

agent_os/cli.py

@@ -0,0 +1,44 @@
+"""
+Agent OS CLI - Command line interface for Agent OS
+
+Usage:
+    agentctl status          # Check installation status
+    agentctl kernel start    # Start kernel (future)
+    agentctl agent list      # List agents (future)
+"""
+
+import argparse
+import sys
+
+
+def main():
+    """Main entry point for Agent OS CLI."""
+    parser = argparse.ArgumentParser(
+        prog="agentctl",
+        description="Agent OS - A Safety-First Kernel for Autonomous AI Agents",
+    )
+    
+    subparsers = parser.add_subparsers(dest="command", help="Commands")
+    
+    # Status command
+    status_parser = subparsers.add_parser("status", help="Check installation status")
+    
+    # Version command
+    version_parser = subparsers.add_parser("version", help="Show version")
+    
+    # Parse args
+    args = parser.parse_args()
+    
+    if args.command == "status":
+        from agent_os import check_installation
+        check_installation()
+    elif args.command == "version":
+        from agent_os import __version__
+        print(f"Agent OS v{__version__}")
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

agent_os/integrations/__init__.py

@@ -0,0 +1,17 @@
+"""
+Agent OS Integrations
+
+Adapters to wrap existing agent frameworks with Agent OS governance.
+"""
+
+from .langchain_adapter import LangChainKernel
+from .crewai_adapter import CrewAIKernel
+from .autogen_adapter import AutoGenKernel
+from .base import BaseIntegration
+
+__all__ = [
+    "LangChainKernel",
+    "CrewAIKernel", 
+    "AutoGenKernel",
+    "BaseIntegration",
+]

agent_os/integrations/autogen_adapter.py

@@ -0,0 +1,144 @@
+"""
+AutoGen Integration
+
+Wraps Microsoft AutoGen agents with Agent OS governance.
+
+Usage:
+    from agent_os.integrations import AutoGenKernel
+    
+    kernel = AutoGenKernel()
+    kernel.govern(agent1, agent2, agent3)
+    
+    # Now all conversations are governed
+    agent1.initiate_chat(agent2, message="...")
+"""
+
+from typing import Any, Optional, List
+
+from .base import BaseIntegration, GovernancePolicy, ExecutionContext
+
+
+class AutoGenKernel(BaseIntegration):
+    """
+    AutoGen adapter for Agent OS.
+    
+    Supports:
+    - AssistantAgent
+    - UserProxyAgent
+    - GroupChat
+    - Conversation flows
+    """
+    
+    def __init__(self, policy: Optional[GovernancePolicy] = None):
+        super().__init__(policy)
+        self._governed_agents: dict[str, Any] = {}
+    
+    def wrap(self, agent: Any) -> Any:
+        """Wrap a single AutoGen agent"""
+        return self.govern(agent)[0]
+    
+    def govern(self, *agents: Any) -> List[Any]:
+        """
+        Add governance to multiple AutoGen agents.
+        
+        Intercepts:
+        - initiate_chat()
+        - generate_reply()
+        - receive()
+        - send()
+        """
+        governed = []
+        
+        for agent in agents:
+            agent_id = getattr(agent, 'name', f"autogen-{id(agent)}")
+            ctx = self.create_context(agent_id)
+            
+            # Store reference
+            self._governed_agents[agent_id] = agent
+            
+            # Wrap key methods
+            self._wrap_initiate_chat(agent, ctx)
+            self._wrap_generate_reply(agent, ctx)
+            self._wrap_receive(agent, ctx)
+            
+            governed.append(agent)
+        
+        return governed
+    
+    def _wrap_initiate_chat(self, agent: Any, ctx: ExecutionContext):
+        """Wrap initiate_chat method"""
+        if not hasattr(agent, 'initiate_chat'):
+            return
+        
+        original = agent.initiate_chat
+        kernel = self
+        
+        def governed_initiate_chat(recipient, message=None, **kwargs):
+            allowed, reason = kernel.pre_execute(ctx, {"recipient": str(recipient), "message": message})
+            if not allowed:
+                from .langchain_adapter import PolicyViolationError
+                raise PolicyViolationError(reason)
+            
+            result = original(recipient, message=message, **kwargs)
+            
+            kernel.post_execute(ctx, result)
+            return result
+        
+        agent.initiate_chat = governed_initiate_chat
+    
+    def _wrap_generate_reply(self, agent: Any, ctx: ExecutionContext):
+        """Wrap generate_reply method"""
+        if not hasattr(agent, 'generate_reply'):
+            return
+        
+        original = agent.generate_reply
+        kernel = self
+        
+        def governed_generate_reply(messages=None, sender=None, **kwargs):
+            allowed, reason = kernel.pre_execute(ctx, {"messages": messages, "sender": str(sender)})
+            if not allowed:
+                return f"[BLOCKED: {reason}]"
+            
+            result = original(messages=messages, sender=sender, **kwargs)
+            
+            valid, reason = kernel.post_execute(ctx, result)
+            if not valid:
+                return f"[BLOCKED: {reason}]"
+            
+            return result
+        
+        agent.generate_reply = governed_generate_reply
+    
+    def _wrap_receive(self, agent: Any, ctx: ExecutionContext):
+        """Wrap receive method"""
+        if not hasattr(agent, 'receive'):
+            return
+        
+        original = agent.receive
+        kernel = self
+        
+        def governed_receive(message, sender, **kwargs):
+            allowed, reason = kernel.pre_execute(ctx, {"message": message, "sender": str(sender)})
+            if not allowed:
+                from .langchain_adapter import PolicyViolationError
+                raise PolicyViolationError(reason)
+            
+            result = original(message, sender, **kwargs)
+            
+            kernel.post_execute(ctx, result)
+            return result
+        
+        agent.receive = governed_receive
+    
+    def unwrap(self, governed_agent: Any) -> Any:
+        """Note: AutoGen agents are modified in-place, can't easily unwrap"""
+        raise NotImplementedError(
+            "AutoGen agents are governed in-place. "
+            "Create a new agent instance if you need ungoverned access."
+        )
+
+
+# Convenience function
+def govern(*agents: Any, policy: Optional[GovernancePolicy] = None) -> List[Any]:
+    """Quick governance for AutoGen agents"""
+    return AutoGenKernel(policy).govern(*agents)

agent_os/integrations/base.py

@@ -0,0 +1,133 @@
+"""
+Base Integration Interface
+
+All framework adapters inherit from this base class.
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Any, Callable, Optional
+from datetime import datetime
+
+
+@dataclass
+class GovernancePolicy:
+    """Policy configuration for governed agents"""
+    max_tokens: int = 4096
+    max_tool_calls: int = 10
+    allowed_tools: list[str] = field(default_factory=list)
+    blocked_patterns: list[str] = field(default_factory=list)
+    require_human_approval: bool = False
+    timeout_seconds: int = 300
+    
+    # Safety thresholds
+    confidence_threshold: float = 0.8
+    drift_threshold: float = 0.15
+    
+    # Audit settings
+    log_all_calls: bool = True
+    checkpoint_frequency: int = 5  # Every N calls
+
+
+@dataclass
+class ExecutionContext:
+    """Context passed through the governance layer"""
+    agent_id: str
+    session_id: str
+    policy: GovernancePolicy
+    start_time: datetime = field(default_factory=datetime.now)
+    call_count: int = 0
+    tool_calls: list[dict] = field(default_factory=list)
+    checkpoints: list[str] = field(default_factory=list)
+
+
+class BaseIntegration(ABC):
+    """
+    Base class for framework integrations.
+    
+    Wraps any agent framework with Agent OS governance:
+    - Pre-execution policy checks
+    - Post-execution validation
+    - Flight recording
+    - Signal handling
+    """
+    
+    def __init__(self, policy: Optional[GovernancePolicy] = None):
+        self.policy = policy or GovernancePolicy()
+        self.contexts: dict[str, ExecutionContext] = {}
+        self._signal_handlers: dict[str, Callable] = {}
+    
+    @abstractmethod
+    def wrap(self, agent: Any) -> Any:
+        """
+        Wrap an agent with governance.
+        
+        Returns a governed version of the agent that:
+        - Enforces policy on all operations
+        - Records execution to flight recorder
+        - Responds to signals (SIGSTOP, SIGKILL, etc.)
+        """
+        pass
+    
+    @abstractmethod
+    def unwrap(self, governed_agent: Any) -> Any:
+        """Remove governance wrapper and return original agent"""
+        pass
+    
+    def create_context(self, agent_id: str) -> ExecutionContext:
+        """Create execution context for an agent"""
+        from uuid import uuid4
+        ctx = ExecutionContext(
+            agent_id=agent_id,
+            session_id=str(uuid4())[:8],
+            policy=self.policy
+        )
+        self.contexts[agent_id] = ctx
+        return ctx
+    
+    def pre_execute(self, ctx: ExecutionContext, input_data: Any) -> tuple[bool, Optional[str]]:
+        """
+        Pre-execution policy check.
+        
+        Returns (allowed, reason) tuple.
+        """
+        # Check call count
+        if ctx.call_count >= self.policy.max_tool_calls:
+            return False, f"Max tool calls exceeded ({self.policy.max_tool_calls})"
+        
+        # Check timeout
+        elapsed = (datetime.now() - ctx.start_time).total_seconds()
+        if elapsed > self.policy.timeout_seconds:
+            return False, f"Timeout exceeded ({self.policy.timeout_seconds}s)"
+        
+        # Check blocked patterns
+        input_str = str(input_data)
+        for pattern in self.policy.blocked_patterns:
+            if pattern.lower() in input_str.lower():
+                return False, f"Blocked pattern detected: {pattern}"
+        
+        return True, None
+    
+    def post_execute(self, ctx: ExecutionContext, output_data: Any) -> tuple[bool, Optional[str]]:
+        """
+        Post-execution validation.
+        
+        Returns (valid, reason) tuple.
+        """
+        ctx.call_count += 1
+        
+        # Checkpoint if needed
+        if ctx.call_count % self.policy.checkpoint_frequency == 0:
+            checkpoint_id = f"checkpoint-{ctx.call_count}"
+            ctx.checkpoints.append(checkpoint_id)
+        
+        return True, None
+    
+    def on_signal(self, signal: str, handler: Callable):
+        """Register a signal handler"""
+        self._signal_handlers[signal] = handler
+    
+    def signal(self, agent_id: str, signal: str):
+        """Send signal to agent"""
+        if signal in self._signal_handlers:
+            self._signal_handlers[signal](agent_id)

agent_os/integrations/crewai_adapter.py

@@ -0,0 +1,121 @@
+"""
+CrewAI Integration
+
+Wraps CrewAI crews and agents with Agent OS governance.
+
+Usage:
+    from agent_os.integrations import CrewAIKernel
+    
+    kernel = CrewAIKernel()
+    governed_crew = kernel.wrap(my_crew)
+    
+    # Now all crew executions go through Agent OS
+    result = governed_crew.kickoff()
+"""
+
+from typing import Any, Optional
+
+from .base import BaseIntegration, GovernancePolicy, ExecutionContext
+
+
+class CrewAIKernel(BaseIntegration):
+    """
+    CrewAI adapter for Agent OS.
+    
+    Supports:
+    - Crew (kickoff, kickoff_async)
+    - Individual agents within crews
+    - Task execution monitoring
+    """
+    
+    def __init__(self, policy: Optional[GovernancePolicy] = None):
+        super().__init__(policy)
+        self._wrapped_crews: dict[int, Any] = {}
+    
+    def wrap(self, crew: Any) -> Any:
+        """
+        Wrap a CrewAI crew with governance.
+        
+        Intercepts:
+        - kickoff() / kickoff_async()
+        - Individual agent executions
+        - Task completions
+        """
+        crew_id = getattr(crew, 'id', None) or f"crew-{id(crew)}"
+        ctx = self.create_context(crew_id)
+        
+        self._wrapped_crews[id(crew)] = crew
+        
+        original = crew
+        kernel = self
+        
+        class GovernedCrewAICrew:
+            """CrewAI crew wrapped with Agent OS governance"""
+            
+            def __init__(self):
+                self._original = original
+                self._ctx = ctx
+                self._kernel = kernel
+            
+            def kickoff(self, inputs: dict = None) -> Any:
+                """Governed kickoff"""
+                allowed, reason = self._kernel.pre_execute(self._ctx, inputs)
+                if not allowed:
+                    from .langchain_adapter import PolicyViolationError
+                    raise PolicyViolationError(reason)
+                
+                # Wrap individual agents if possible
+                if hasattr(self._original, 'agents'):
+                    for agent in self._original.agents:
+                        self._wrap_agent(agent)
+                
+                result = self._original.kickoff(inputs)
+                
+                valid, reason = self._kernel.post_execute(self._ctx, result)
+                if not valid:
+                    from .langchain_adapter import PolicyViolationError
+                    raise PolicyViolationError(reason)
+                
+                return result
+            
+            async def kickoff_async(self, inputs: dict = None) -> Any:
+                """Governed async kickoff"""
+                allowed, reason = self._kernel.pre_execute(self._ctx, inputs)
+                if not allowed:
+                    from .langchain_adapter import PolicyViolationError
+                    raise PolicyViolationError(reason)
+                
+                result = await self._original.kickoff_async(inputs)
+                
+                valid, reason = self._kernel.post_execute(self._ctx, result)
+                if not valid:
+                    from .langchain_adapter import PolicyViolationError
+                    raise PolicyViolationError(reason)
+                
+                return result
+            
+            def _wrap_agent(self, agent):
+                """Add governance hooks to individual agent"""
+                original_execute = getattr(agent, 'execute_task', None)
+                if original_execute:
+                    def governed_execute(task, *args, **kwargs):
+                        self._kernel.pre_execute(self._ctx, task)
+                        result = original_execute(task, *args, **kwargs)
+                        self._kernel.post_execute(self._ctx, result)
+                        return result
+                    agent.execute_task = governed_execute
+            
+            def __getattr__(self, name):
+                return getattr(self._original, name)
+        
+        return GovernedCrewAICrew()
+    
+    def unwrap(self, governed_crew: Any) -> Any:
+        """Get original crew from wrapped version"""
+        return governed_crew._original
+
+
+# Convenience function
+def wrap(crew: Any, policy: Optional[GovernancePolicy] = None) -> Any:
+    """Quick wrapper for CrewAI crews"""
+    return CrewAIKernel(policy).wrap(crew)

agent_os/integrations/langchain_adapter.py

@@ -0,0 +1,157 @@
+"""
+LangChain Integration
+
+Wraps LangChain agents/chains with Agent OS governance.
+
+Usage:
+    from agent_os.integrations import LangChainKernel
+    
+    kernel = LangChainKernel()
+    governed_chain = kernel.wrap(my_langchain_chain)
+    
+    # Now all invocations go through Agent OS
+    result = governed_chain.invoke({"input": "..."})
+"""
+
+from typing import Any, Optional
+from functools import wraps
+
+from .base import BaseIntegration, GovernancePolicy, ExecutionContext
+
+
+class LangChainKernel(BaseIntegration):
+    """
+    LangChain adapter for Agent OS.
+    
+    Supports:
+    - Chains (invoke, ainvoke)
+    - Agents (run, arun)
+    - Runnables (invoke, batch, stream)
+    """
+    
+    def __init__(self, policy: Optional[GovernancePolicy] = None):
+        super().__init__(policy)
+        self._wrapped_agents: dict[int, Any] = {}  # id(wrapped) -> original
+    
+    def wrap(self, agent: Any) -> Any:
+        """
+        Wrap a LangChain agent/chain with governance.
+        
+        Intercepts:
+        - invoke() / ainvoke()
+        - run() / arun()
+        - batch() / abatch()
+        - stream() / astream()
+        """
+        # Get agent ID from the object
+        agent_id = getattr(agent, 'name', None) or f"langchain-{id(agent)}"
+        ctx = self.create_context(agent_id)
+        
+        # Store original
+        self._wrapped_agents[id(agent)] = agent
+        
+        # Create wrapper class
+        original = agent
+        kernel = self
+        
+        class GovernedLangChainAgent:
+            """LangChain agent wrapped with Agent OS governance"""
+            
+            def __init__(self):
+                self._original = original
+                self._ctx = ctx
+                self._kernel = kernel
+            
+            def invoke(self, input_data: Any, **kwargs) -> Any:
+                """Governed invoke"""
+                # Pre-check
+                allowed, reason = self._kernel.pre_execute(self._ctx, input_data)
+                if not allowed:
+                    raise PolicyViolationError(reason)
+                
+                # Execute
+                result = self._original.invoke(input_data, **kwargs)
+                
+                # Post-check
+                valid, reason = self._kernel.post_execute(self._ctx, result)
+                if not valid:
+                    raise PolicyViolationError(reason)
+                
+                return result
+            
+            async def ainvoke(self, input_data: Any, **kwargs) -> Any:
+                """Governed async invoke"""
+                allowed, reason = self._kernel.pre_execute(self._ctx, input_data)
+                if not allowed:
+                    raise PolicyViolationError(reason)
+                
+                result = await self._original.ainvoke(input_data, **kwargs)
+                
+                valid, reason = self._kernel.post_execute(self._ctx, result)
+                if not valid:
+                    raise PolicyViolationError(reason)
+                
+                return result
+            
+            def run(self, *args, **kwargs) -> Any:
+                """Governed run (for agents)"""
+                input_data = args[0] if args else kwargs
+                allowed, reason = self._kernel.pre_execute(self._ctx, input_data)
+                if not allowed:
+                    raise PolicyViolationError(reason)
+                
+                result = self._original.run(*args, **kwargs)
+                
+                valid, reason = self._kernel.post_execute(self._ctx, result)
+                if not valid:
+                    raise PolicyViolationError(reason)
+                
+                return result
+            
+            def batch(self, inputs: list, **kwargs) -> list:
+                """Governed batch"""
+                for inp in inputs:
+                    allowed, reason = self._kernel.pre_execute(self._ctx, inp)
+                    if not allowed:
+                        raise PolicyViolationError(reason)
+                
+                results = self._original.batch(inputs, **kwargs)
+                
+                for result in results:
+                    valid, reason = self._kernel.post_execute(self._ctx, result)
+                    if not valid:
+                        raise PolicyViolationError(reason)
+                
+                return results
+            
+            def stream(self, input_data: Any, **kwargs):
+                """Governed stream"""
+                allowed, reason = self._kernel.pre_execute(self._ctx, input_data)
+                if not allowed:
+                    raise PolicyViolationError(reason)
+                
+                for chunk in self._original.stream(input_data, **kwargs):
+                    yield chunk
+                
+                self._kernel.post_execute(self._ctx, None)
+            
+            # Passthrough for non-execution methods
+            def __getattr__(self, name):
+                return getattr(self._original, name)
+        
+        return GovernedLangChainAgent()
+    
+    def unwrap(self, governed_agent: Any) -> Any:
+        """Get original agent from wrapped version"""
+        return governed_agent._original
+
+
+class PolicyViolationError(Exception):
+    """Raised when an agent violates governance policy"""
+    pass
+
+
+# Convenience function
+def wrap(agent: Any, policy: Optional[GovernancePolicy] = None) -> Any:
+    """Quick wrapper for LangChain agents"""
+    return LangChainKernel(policy).wrap(agent)

agent_os_kernel-1.1.0.dist-info/METADATA

@@ -0,0 +1,400 @@
+Metadata-Version: 2.4
+Name: agent-os-kernel
+Version: 1.1.0
+Summary: A Safety-First Kernel for Autonomous AI Agents - POSIX-inspired primitives with 0% policy violation guarantee
+Project-URL: Homepage, https://github.com/imran-siddique/agent-os
+Project-URL: Documentation, https://github.com/imran-siddique/agent-os/tree/master/docs
+Project-URL: Repository, https://github.com/imran-siddique/agent-os
+Project-URL: Bug Tracker, https://github.com/imran-siddique/agent-os/issues
+Project-URL: Changelog, https://github.com/imran-siddique/agent-os/blob/master/CHANGELOG.md
+Author-email: Imran Siddique <imran.siddique@microsoft.com>
+Maintainer-email: Imran Siddique <imran.siddique@microsoft.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,ai,autonomous,control-plane,governance,kernel,llm,multi-agent,posix,safety,signals,vfs
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Operating System Kernels
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: all
+Requires-Dist: agent-os[dev,docs,full]; extra == 'all'
+Provides-Extra: amb
+Requires-Dist: aiofiles>=23.0.0; extra == 'amb'
+Requires-Dist: anyio>=3.0.0; extra == 'amb'
+Provides-Extra: atr
+Requires-Dist: docker>=6.0.0; extra == 'atr'
+Provides-Extra: caas
+Requires-Dist: fastapi>=0.100.0; extra == 'caas'
+Requires-Dist: numpy>=1.20.0; extra == 'caas'
+Requires-Dist: pypdf2>=3.0.0; extra == 'caas'
+Requires-Dist: scikit-learn>=1.0.0; extra == 'caas'
+Requires-Dist: uvicorn>=0.20.0; extra == 'caas'
+Provides-Extra: cmvk
+Requires-Dist: numpy>=1.20.0; extra == 'cmvk'
+Provides-Extra: control-plane
+Provides-Extra: core
+Requires-Dist: agent-os[cmvk,control-plane,primitives]; extra == 'core'
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.0.0; extra == 'docs'
+Requires-Dist: mkdocs>=1.5.0; extra == 'docs'
+Requires-Dist: mkdocstrings[python]>=0.24.0; extra == 'docs'
+Provides-Extra: emk
+Requires-Dist: chromadb>=0.4.0; extra == 'emk'
+Requires-Dist: numpy>=1.20.0; extra == 'emk'
+Provides-Extra: full
+Requires-Dist: agent-os[amb,atr,caas,cmvk,control-plane,emk,iatp,mute-agent,primitives,scak]; extra == 'full'
+Provides-Extra: iatp
+Requires-Dist: fastapi>=0.100.0; extra == 'iatp'
+Requires-Dist: httpx>=0.24.0; extra == 'iatp'
+Requires-Dist: uvicorn>=0.20.0; extra == 'iatp'
+Provides-Extra: infrastructure
+Requires-Dist: agent-os[amb,atr,iatp]; extra == 'infrastructure'
+Provides-Extra: intelligence
+Requires-Dist: agent-os[mute-agent,scak]; extra == 'intelligence'
+Provides-Extra: mute-agent
+Provides-Extra: primitives
+Provides-Extra: scak
+Requires-Dist: pyyaml>=6.0; extra == 'scak'
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+# Agent OS
+
+### The Linux Kernel for AI Agents
+
+**0% Safety Violations • Deterministic Enforcement • POSIX-Inspired**
+
+[![PyPI](https://img.shields.io/pypi/v/agent-os?label=PyPI)](https://pypi.org/project/agent-os/)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Python](https://img.shields.io/badge/python-3.10+-blue.svg)](https://python.org)
+
+[Quick Start](#-quick-start) • [Why Agent OS?](#-why-agent-os) • [Demos](#-live-demos) • [Integrations](#-integrations) • [Contributing](#-contributing)
+
+</div>
+
+---
+
+## 🎯 What is Agent OS?
+
+**Agent OS treats LLMs like raw compute and provides OS-level governance.** 
+
+Current AI agent frameworks let the LLM "decide" everything - including whether to follow safety rules. Agent OS inverts this: the **kernel decides**, the LLM just computes.
+
+```
+┌─────────────────────────────────────────────────────────┐
+│              USER SPACE (Untrusted LLM)                 │
+│   Your agent code runs here. It can crash, hallucinate, │
+│   or misbehave - the kernel survives.                   │
+├─────────────────────────────────────────────────────────┤
+│              KERNEL SPACE (Trusted)                     │
+│   Policy Engine │ Flight Recorder │ Signal Dispatch     │
+│   If agent violates policy → SIGKILL (non-catchable)   │
+└─────────────────────────────────────────────────────────┘
+```
+
+## ❓ Why Agent OS?
+
+### The Problem with Current Approaches
+
+| Approach | How it works | Why it fails |
+|----------|--------------|--------------|
+| **Prompt-based safety** | "Please don't do bad things" | LLM can ignore prompts |
+| **Constitutional AI** | Train model to be safe | Training doesn't guarantee |
+| **Guardrails** | Check output after generation | Too late - damage done |
+| **Agent OS** | **Kernel-level enforcement** | **Can't bypass the kernel** |
+
+### Real Benchmark Results
+
+| Metric | Prompt-based | Agent OS |
+|--------|-------------|----------|
+| Safety Violations | 26.67% | **0.00%** |
+| Response Tokens | 26.1 avg | **0.5 avg** |
+| Deterministic | No | **Yes** |
+
+## 🚀 Quick Start
+
+### Option 1: pip install (30 seconds)
+
+```bash
+pip install agent-os
+
+# Verify installation
+python -c "from agent_os import KernelSpace; print('Agent OS ready!')"
+```
+
+### Option 2: GitHub CLI Extension (Recommended for daily use)
+
+```bash
+# Install the gh extension
+gh extension install imran-siddique/gh-agent-os
+
+# Now use Agent OS directly from your terminal
+gh agent-os run "analyze this codebase for security issues"
+gh agent-os audit --policy pci-dss
+gh agent-os status
+```
+
+### Option 3: Docker (Production)
+
+```bash
+docker pull ghcr.io/imran-siddique/agent-os:latest
+docker run -it agent-os agentctl --help
+```
+
+## 💡 Core Concepts (5 minutes)
+
+### 1. Signals - Control Your Agents Like Processes
+
+```python
+from agent_os import AgentSignal, SignalDispatcher
+
+# Pause agent to inspect state (like Ctrl+Z)
+dispatcher.signal(agent_id, AgentSignal.SIGSTOP)
+
+# Resume execution
+dispatcher.signal(agent_id, AgentSignal.SIGCONT)
+
+# Policy violation? Kernel kills it (non-catchable)
+dispatcher.signal(agent_id, AgentSignal.SIGKILL)
+```
+
+### 2. Virtual File System - Memory That Makes Sense
+
+```python
+from agent_os import AgentVFS
+
+vfs = AgentVFS(agent_id="agent-001")
+
+# Standard mount points (like /home, /tmp, /etc)
+vfs.write("/mem/working/task.txt", "Current task...")  # Ephemeral
+vfs.write("/mem/episodic/session.log", "What happened")  # Experience
+vfs.read("/policy/allowed_actions.yaml")  # Read-only rules
+```
+
+### 3. IPC Pipes - Agents Talk Through Policies
+
+```python
+from agent_os.iatp import Pipeline, PolicyCheckPipe
+
+# Unix-style piping: agent1 | policy | agent2
+pipeline = Pipeline([
+    research_agent,
+    PolicyCheckPipe(allowed=["ResearchResult"]),  # Type check!
+    summary_agent
+])
+
+# If research_agent outputs wrong type → pipeline fails safely
+result = await pipeline.execute("Find recent AI papers")
+```
+
+## 🎬 Live Demos
+
+Four production-ready demos showing Agent OS in action:
+
+| Demo | Industry | What it shows | Run it |
+|------|----------|---------------|--------|
+| **[Carbon Auditor](examples/carbon-auditor/)** | Climate | CMVK drift detection catches $5M fraud | `python examples/carbon-auditor/demo.py` |
+| **[Grid Balancing](examples/grid-balancing/)** | Energy | 100 agents negotiate in 100ms | `python examples/grid-balancing/demo.py` |
+| **[DeFi Sentinel](examples/defi-sentinel/)** | Crypto | Stop hacks in 142ms | `python examples/defi-sentinel/demo.py` |
+| **[Pharma Compliance](examples/pharma-compliance/)** | Healthcare | Find contradictions in 100K pages | `python examples/pharma-compliance/demo.py` |
+
+```bash
+# Run all demos
+cd examples && docker-compose up
+```
+
+## 🔌 Integrations
+
+### Works With Your Existing Stack
+
+Agent OS doesn't replace your tools - it governs them:
+
+```python
+# With LangChain
+from agent_os.integrations import langchain_kernel
+chain = langchain_kernel.wrap(your_langchain_agent)
+
+# With CrewAI
+from agent_os.integrations import crewai_kernel
+crew = crewai_kernel.wrap(your_crew)
+
+# With AutoGen
+from agent_os.integrations import autogen_kernel
+autogen_kernel.govern(your_autogen_agents)
+```
+
+### GitHub Integration
+
+```yaml
+# .github/workflows/agent-os.yml
+name: Agent OS Safety Check
+on: [push, pull_request]
+
+jobs:
+  safety-audit:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: imran-siddique/agent-os-action@v1
+        with:
+          policy: .agent-os/policy.yaml
+          fail-on-violation: true
+```
+
+### VS Code Extension
+
+```bash
+# Install from marketplace
+code --install-extension imran-siddique.agent-os
+
+# Or use Command Palette: "Agent OS: Audit Current File"
+```
+
+### CLI for Daily Workflows
+
+```bash
+# Audit any agent codebase
+agentctl audit ./my-agent-project
+
+# Run with safety constraints
+agentctl run --policy strict "agent.py"
+
+# Monitor running agents
+agentctl status --watch
+
+# Replay agent execution from flight recorder
+agentctl replay --from checkpoint-001
+```
+
+## 📦 Package Architecture
+
+```
+agent-os/
+├── L1: Primitives (Foundation)
+│   ├── primitives     # Failure types, base models
+│   ├── cmvk           # Cross-model verification
+│   ├── caas           # Context-as-a-Service
+│   └── emk            # Episodic Memory Kernel
+│
+├── L2: Infrastructure (Communication)
+│   ├── iatp           # Inter-Agent Trust Protocol
+│   ├── amb            # Agent Message Bus
+│   └── atr            # Agent Tool Registry
+│
+├── L3: Framework (Governance)
+│   └── control-plane  # Kernel, signals, VFS
+│
+└── L4: Intelligence (Self-Correction)
+    ├── scak           # Self-Correcting Agent Kernel
+    └── mute-agent     # Reasoning/Execution split
+```
+
+Install what you need:
+
+```bash
+pip install agent-os              # Core only
+pip install agent-os[control-plane]  # + Governance
+pip install agent-os[full]        # Everything
+```
+
+## 🆚 How We Compare
+
+| Feature | LangChain | AutoGen | CrewAI | AIOS | **Agent OS** |
+|---------|-----------|---------|--------|------|--------------|
+| Multi-agent | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Safety guarantees | ❌ | ❌ | ❌ | ❌ | **✅ Kernel-level** |
+| Deterministic | ❌ | ❌ | ❌ | ❌ | **✅** |
+| Process isolation | ❌ | ❌ | ❌ | ❌ | **✅ Kernel/User** |
+| Policy enforcement | ❌ | ❌ | ❌ | ❌ | **✅ SIGKILL** |
+| Audit trail | Partial | Partial | Partial | ❌ | **✅ Flight Recorder** |
+| Memory model | Ad-hoc | Ad-hoc | Ad-hoc | Short/Long | **✅ VFS** |
+
+**TL;DR**: Other frameworks help you *build* agents. Agent OS helps you *trust* them.
+
+## 🤝 Contributing
+
+We welcome contributions! Agent OS is designed to be extended.
+
+### Good First Issues
+
+- 🏷️ [`good-first-issue`](https://github.com/imran-siddique/agent-os/labels/good-first-issue) - Perfect for newcomers
+- 📚 [`documentation`](https://github.com/imran-siddique/agent-os/labels/documentation) - Help improve docs
+- 🧪 [`needs-tests`](https://github.com/imran-siddique/agent-os/labels/needs-tests) - Add test coverage
+
+### Development Setup
+
+```bash
+# Clone and setup
+git clone https://github.com/imran-siddique/agent-os.git
+cd agent-os
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Run a specific demo
+python examples/carbon-auditor/demo.py
+```
+
+### Integration Bounties
+
+Want to add an integration? We're looking for:
+
+| Integration | Bounty | Status |
+|-------------|--------|--------|
+| LangChain adapter | 🎁 | Open |
+| CrewAI adapter | 🎁 | Open |
+| AutoGen adapter | 🎁 | Open |
+| OpenAI Swarm adapter | 🎁 | Open |
+| Anthropic Claude adapter | 🎁 | Open |
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for full guidelines.
+
+## 📖 Documentation
+
+- **[Architecture Guide](docs/architecture.md)** - Deep dive into kernel design
+- **[API Reference](docs/api/)** - Full API documentation
+- **[Examples](examples/)** - Working demos
+- **[AIOS Comparison](docs/AIOS_COMPARISON.md)** - Detailed competitor analysis
+
+## 🔬 Research
+
+Agent OS is designed for both production and academic use:
+
+- **Target**: ASPLOS 2026 Workshop on Agentic Systems
+- **Paper**: "Agent OS: A Safety-First Kernel for Autonomous AI Agents"
+- **Novel Contribution**: First OS-level governance for LLM agents
+
+## 📜 License
+
+MIT License - Use it, modify it, ship it. See [LICENSE](LICENSE).
+
+---
+
+<div align="center">
+
+**Built for engineers who don't trust their agents (yet).**
+
+[⭐ Star us on GitHub](https://github.com/imran-siddique/agent-os) • [📦 PyPI](https://pypi.org/project/agent-os/) • [💬 Discussions](https://github.com/imran-siddique/agent-os/discussions)
+
+</div>

agent_os_kernel-1.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+agent_os/__init__.py,sha256=3GVytq4q7NrLk1-lB3E5d_IuuufGTH5_NL5dcjXkXOA,8085
+agent_os/cli.py,sha256=UUbxQPCptpCnO9m3uPaRQESYzdSMwkRB-PWTDHctCpE,1186
+agent_os/integrations/__init__.py,sha256=jQaIoLNWYXLwoLU0w6WYf8Pi2n988z-a9EGVzCaDt2Y,386
+agent_os/integrations/autogen_adapter.py,sha256=KFyEw4Y_IYgQM6CpaTjCHs9HCX8hPiCzeAz2E__AVrg,4742
+agent_os/integrations/base.py,sha256=0CZOtHC52Eg5wdr5qYI1s40nnSvbXvz8PeJ1LF97Bc0,4356
+agent_os/integrations/crewai_adapter.py,sha256=B0uppXizOuvj9PTd89lxMDoedBzdrt8XlRZXNSfJdbs,4395
+agent_os/integrations/langchain_adapter.py,sha256=SrGFv9m_IfMwklc58_Nv8WRNdcyOIEAYSPcjTRFTLoQ,5636
+agent_os_kernel-1.1.0.dist-info/METADATA,sha256=L6bSJ1UOlirp0io5xlsT9j1W7xps6gZw-eqViaXVH1M,13610
+agent_os_kernel-1.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+agent_os_kernel-1.1.0.dist-info/entry_points.txt,sha256=wh7atGeSHUk0eDOU8r94VhahDenzOcyp7O9uBygjXl0,76
+agent_os_kernel-1.1.0.dist-info/licenses/LICENSE,sha256=6rUhFLV_7Agj5qal2I4M8h66QadoY6xf51VOz8m7BrQ,1097
+agent_os_kernel-1.1.0.dist-info/RECORD,,

agent_os_kernel-1.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

agent_os_kernel-1.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+agent-os = agent_os.cli:main
+agentctl = agent_os.cli:main

agent_os_kernel-1.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2026 Imran Siddique
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.