# All entities are workspace-scoped
class Agent(BaseModel, WorkspaceScopedMixin):
    id: UUID
    name: str
    workspace_id: UUID  # Required for isolation

network_policy:
  workspace_id: "ws-123"
  
  rules:
    # Allow researcher to send to writer
    - from: "researcher-agent"
      to: "writer-agent"
      action: allow
      channels: ["tasks", "messages"]
    
    # Deny direct access to database agent
    - from: "researcher-agent"
      to: "database-agent"
      action: deny
    
    # Allow manager to communicate with all
    - from: "manager-agent"
      to: "*"
      action: allow

# Repository pattern enforces workspace scoping
class WorkspaceScopedRepository(Generic[T]):
    def __init__(self, session: AsyncSession, user_context: UserContext):
        self.session = session
        self.workspace_id = user_context.workspace_id
    
    async def list(self) -> list[T]:
        # Automatically filters by workspace
        return await self.session.execute(
            select(self.model).where(
                self.model.workspace_id == self.workspace_id
            )
        )

@dataclass
class UserContext:
    user_id: str
    workspace_id: str
    roles: list[str] | None = None

# Internal routing
class A2ABridge:
    async def route_message(
        self, 
        from_agent: str, 
        to_agent: str, 
        message: dict
    ):
        # Check network policy
        if not self.policy.is_allowed(from_agent, to_agent):
            raise CommunicationDeniedError()
        
        # Route to target agent
        await self.agent_manager.deliver(to_agent, message)