diff --git a/.github/workflows/python-tests.yml b/.github/workflows/python-tests.yml
new file mode 100644
index 00000000..a75413b8
--- /dev/null
+++ b/.github/workflows/python-tests.yml
@@ -0,0 +1,93 @@
+name: Python Unit Tests
+
+on:
+  pull_request:
+    paths:
+      - 'libs/python/**'
+      - '.github/workflows/python-tests.yml'
+  push:
+    branches:
+      - main
+    paths:
+      - 'libs/python/**'
+      - '.github/workflows/python-tests.yml'
+  workflow_dispatch:  # Allow manual trigger
+
+jobs:
+  test:
+    name: Test ${{ matrix.package }}
+    runs-on: ubuntu-latest
+    
+    strategy:
+      fail-fast: false  # Test all packages even if one fails
+      matrix:
+        package:
+          - core
+          - agent
+          - computer
+          - computer-server
+          - mcp-server
+          - pylume
+          - som
+    
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      
+      - name: Install uv
+        run: |
+          pip install uv
+      
+      - name: Install package and dependencies
+        run: |
+          cd libs/python/${{ matrix.package }}
+          # Install the package in editable mode with dev dependencies
+          if [ -f pyproject.toml ]; then
+            uv pip install --system -e .
+            # Install test dependencies
+            uv pip install --system pytest pytest-asyncio pytest-mock pytest-cov
+          fi
+        shell: bash
+      
+      - name: Run tests
+        run: |
+          cd libs/python/${{ matrix.package }}
+          if [ -d tests ]; then
+            python -m pytest tests/ -v --tb=short --cov --cov-report=term --cov-report=xml
+          else
+            echo "No tests directory found, skipping tests"
+          fi
+        shell: bash
+        env:
+          CUA_TELEMETRY_DISABLED: "1"  # Disable telemetry during tests
+      
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v4
+        if: always()
+        with:
+          file: ./libs/python/${{ matrix.package }}/coverage.xml
+          flags: ${{ matrix.package }}
+          name: codecov-${{ matrix.package }}
+          fail_ci_if_error: false
+        continue-on-error: true
+
+  summary:
+    name: Test Summary
+    runs-on: ubuntu-latest
+    needs: test
+    if: always()
+    
+    steps:
+      - name: Check test results
+        run: |
+          if [ "${{ needs.test.result }}" == "failure" ]; then
+            echo "❌ Some tests failed. Please check the logs above."
+            exit 1
+          else
+            echo "✅ All tests passed!"
+          fi
diff --git a/TESTING.md b/TESTING.md
new file mode 100644
index 00000000..1335c64a
--- /dev/null
+++ b/TESTING.md
@@ -0,0 +1,104 @@
+# Testing Guide for CUA
+
+Quick guide to running tests and understanding the test architecture.
+
+## 🚀 Quick Start
+
+```bash
+# Install dependencies
+pip install pytest pytest-asyncio pytest-mock pytest-cov
+
+# Install package
+cd libs/python/core
+pip install -e .
+
+# Run tests
+export CUA_TELEMETRY_DISABLED=1  # or $env:CUA_TELEMETRY_DISABLED="1" on Windows
+pytest tests/ -v
+```
+
+## 🧪 Running Tests
+
+```bash
+# All packages
+pytest libs/python/*/tests/ -v
+
+# Specific package
+cd libs/python/core && pytest tests/ -v
+
+# With coverage
+pytest tests/ --cov --cov-report=html
+
+# Specific test
+pytest tests/test_telemetry.py::TestTelemetryEnabled::test_telemetry_enabled_by_default -v
+```
+
+## 🏗️ Test Architecture
+
+**Principles**: SRP (Single Responsibility) + Vertical Slices + Testability
+
+```
+libs/python/
+├── core/tests/           # Tests ONLY core
+├── agent/tests/          # Tests ONLY agent
+└── computer/tests/       # Tests ONLY computer
+```
+
+Each test file = ONE feature. Each test class = ONE concern.
+
+## ➕ Adding New Tests
+
+1. Create `test_*.py` in the appropriate package's `tests/` directory
+2. Follow the pattern:
+
+```python
+"""Unit tests for my_feature."""
+import pytest
+from unittest.mock import patch
+
+class TestMyFeature:
+    """Test MyFeature class."""
+    
+    def test_initialization(self):
+        """Test that feature initializes."""
+        from my_package import MyFeature
+        feature = MyFeature()
+        assert feature is not None
+```
+
+3. Mock external dependencies:
+
+```python
+@pytest.fixture
+def mock_api():
+    with patch("my_package.api_client") as mock:
+        yield mock
+```
+
+## 🔄 CI/CD
+
+Tests run automatically on every PR via GitHub Actions (`.github/workflows/python-tests.yml`):
+- Matrix strategy: each package tested separately
+- Python 3.12
+- ~2 minute runtime
+
+## 🐛 Troubleshooting
+
+**ModuleNotFoundError**: Run `pip install -e .` in package directory
+
+**Tests fail in CI but pass locally**: Set `CUA_TELEMETRY_DISABLED=1`
+
+**Async tests error**: Install `pytest-asyncio` and use `@pytest.mark.asyncio`
+
+**Mock not working**: Patch at usage location, not definition:
+```python
+# ✅ Right
+@patch("my_package.module.external_function")
+
+# ❌ Wrong  
+@patch("external_library.function")
+```
+
+---
+
+**Questions?** Check existing tests for examples or open an issue.
diff --git a/libs/python/agent/tests/__init__.py b/libs/python/agent/tests/__init__.py
new file mode 100644
index 00000000..a10b299e
--- /dev/null
+++ b/libs/python/agent/tests/__init__.py
@@ -0,0 +1 @@
+"""Unit tests for cua-agent package."""
diff --git a/libs/python/agent/tests/conftest.py b/libs/python/agent/tests/conftest.py
new file mode 100644
index 00000000..d500728c
--- /dev/null
+++ b/libs/python/agent/tests/conftest.py
@@ -0,0 +1,84 @@
+"""Pytest configuration and shared fixtures for agent package tests.
+
+This file contains shared fixtures and configuration for all agent tests.
+Following SRP: This file ONLY handles test setup/teardown.
+"""
+
+import pytest
+from unittest.mock import Mock, AsyncMock, patch, MagicMock
+
+
+@pytest.fixture
+def mock_litellm():
+    """Mock liteLLM completion calls.
+    
+    Use this fixture to avoid making real LLM API calls during tests.
+    Returns a mock that simulates LLM responses.
+    """
+    with patch("litellm.acompletion") as mock_completion:
+        async def mock_response(*args, **kwargs):
+            """Simulate a typical LLM response."""
+            return {
+                "id": "chatcmpl-test123",
+                "object": "chat.completion",
+                "created": 1234567890,
+                "model": kwargs.get("model", "anthropic/claude-3-5-sonnet-20241022"),
+                "choices": [
+                    {
+                        "index": 0,
+                        "message": {
+                            "role": "assistant",
+                            "content": "This is a mocked response for testing.",
+                        },
+                        "finish_reason": "stop",
+                    }
+                ],
+                "usage": {
+                    "prompt_tokens": 10,
+                    "completion_tokens": 20,
+                    "total_tokens": 30,
+                },
+            }
+        
+        mock_completion.side_effect = mock_response
+        yield mock_completion
+
+
+@pytest.fixture
+def mock_computer():
+    """Mock Computer interface for agent tests.
+    
+    Use this fixture to test agent logic without requiring a real Computer instance.
+    """
+    computer = AsyncMock()
+    computer.interface = AsyncMock()
+    computer.interface.screenshot = AsyncMock(return_value=b"fake_screenshot_data")
+    computer.interface.left_click = AsyncMock()
+    computer.interface.type = AsyncMock()
+    computer.interface.key = AsyncMock()
+    
+    # Mock context manager
+    computer.__aenter__ = AsyncMock(return_value=computer)
+    computer.__aexit__ = AsyncMock()
+    
+    return computer
+
+
+@pytest.fixture
+def disable_telemetry(monkeypatch):
+    """Disable telemetry for tests.
+    
+    Use this fixture to ensure no telemetry is sent during tests.
+    """
+    monkeypatch.setenv("CUA_TELEMETRY_DISABLED", "1")
+
+
+@pytest.fixture
+def sample_messages():
+    """Provide sample messages for testing.
+    
+    Returns a list of messages in the expected format.
+    """
+    return [
+        {"role": "user", "content": "Take a screenshot and tell me what you see"}
+    ]
diff --git a/libs/python/agent/tests/test_computer_agent.py b/libs/python/agent/tests/test_computer_agent.py
new file mode 100644
index 00000000..86878e0d
--- /dev/null
+++ b/libs/python/agent/tests/test_computer_agent.py
@@ -0,0 +1,150 @@
+"""Unit tests for ComputerAgent class.
+
+This file tests ONLY the ComputerAgent initialization and basic functionality.
+Following SRP: This file tests ONE class (ComputerAgent).
+All external dependencies (liteLLM, Computer) are mocked.
+"""
+
+import pytest
+from unittest.mock import Mock, AsyncMock, patch, MagicMock
+
+
+class TestComputerAgentInitialization:
+    """Test ComputerAgent initialization (SRP: Only tests initialization)."""
+
+    @patch("agent.agent.litellm")
+    def test_agent_initialization_with_model(self, mock_litellm, disable_telemetry):
+        """Test that agent can be initialized with a model string."""
+        from agent import ComputerAgent
+        
+        agent = ComputerAgent(model="anthropic/claude-3-5-sonnet-20241022")
+        
+        assert agent is not None
+        assert hasattr(agent, "model")
+        assert agent.model == "anthropic/claude-3-5-sonnet-20241022"
+
+    @patch("agent.agent.litellm")
+    def test_agent_initialization_with_tools(self, mock_litellm, disable_telemetry, mock_computer):
+        """Test that agent can be initialized with tools."""
+        from agent import ComputerAgent
+        
+        agent = ComputerAgent(
+            model="anthropic/claude-3-5-sonnet-20241022",
+            tools=[mock_computer]
+        )
+        
+        assert agent is not None
+        assert hasattr(agent, "tools")
+
+    @patch("agent.agent.litellm")
+    def test_agent_initialization_with_max_budget(self, mock_litellm, disable_telemetry):
+        """Test that agent can be initialized with max trajectory budget."""
+        from agent import ComputerAgent
+        
+        budget = 5.0
+        agent = ComputerAgent(
+            model="anthropic/claude-3-5-sonnet-20241022",
+            max_trajectory_budget=budget
+        )
+        
+        assert agent is not None
+
+    @patch("agent.agent.litellm")
+    def test_agent_requires_model(self, mock_litellm, disable_telemetry):
+        """Test that agent requires a model parameter."""
+        from agent import ComputerAgent
+        
+        with pytest.raises(TypeError):
+            # Should fail without model parameter - intentionally missing required argument
+            ComputerAgent()  # type: ignore[call-arg]
+
+
+class TestComputerAgentRun:
+    """Test ComputerAgent.run() method (SRP: Only tests run logic)."""
+
+    @pytest.mark.asyncio
+    @patch("agent.agent.litellm")
+    async def test_agent_run_with_messages(self, mock_litellm, disable_telemetry, sample_messages):
+        """Test that agent.run() works with valid messages."""
+        from agent import ComputerAgent
+        
+        # Mock liteLLM response
+        mock_response = {
+            "id": "chatcmpl-test",
+            "choices": [{
+                "message": {
+                    "role": "assistant",
+                    "content": "Test response"
+                },
+                "finish_reason": "stop"
+            }],
+            "usage": {
+                "prompt_tokens": 10,
+                "completion_tokens": 20,
+                "total_tokens": 30
+            }
+        }
+        
+        mock_litellm.acompletion = AsyncMock(return_value=mock_response)
+        
+        agent = ComputerAgent(model="anthropic/claude-3-5-sonnet-20241022")
+        
+        # Run should return an async generator
+        result_generator = agent.run(sample_messages)
+        
+        assert result_generator is not None
+        # Check it's an async generator
+        assert hasattr(result_generator, '__anext__')
+
+    def test_agent_has_run_method(self, disable_telemetry):
+        """Test that agent has run method available."""
+        from agent import ComputerAgent
+        
+        agent = ComputerAgent(model="anthropic/claude-3-5-sonnet-20241022")
+        
+        # Verify run method exists
+        assert hasattr(agent, "run")
+        assert callable(agent.run)
+
+    def test_agent_has_agent_loop(self, disable_telemetry):
+        """Test that agent has agent_loop initialized."""
+        from agent import ComputerAgent
+        
+        agent = ComputerAgent(model="anthropic/claude-3-5-sonnet-20241022")
+        
+        # Verify agent_loop is initialized
+        assert hasattr(agent, "agent_loop")
+        assert agent.agent_loop is not None
+
+
+class TestComputerAgentTypes:
+    """Test AgentResponse and Messages types (SRP: Only tests type definitions)."""
+
+    def test_messages_type_exists(self):
+        """Test that Messages type is exported."""
+        from agent import Messages
+        
+        assert Messages is not None
+
+    def test_agent_response_type_exists(self):
+        """Test that AgentResponse type is exported."""
+        from agent import AgentResponse
+        
+        assert AgentResponse is not None
+
+
+class TestComputerAgentIntegration:
+    """Test ComputerAgent integration with Computer tool (SRP: Integration within package)."""
+
+    def test_agent_accepts_computer_tool(self, disable_telemetry, mock_computer):
+        """Test that agent can be initialized with Computer tool."""
+        from agent import ComputerAgent
+        
+        agent = ComputerAgent(
+            model="anthropic/claude-3-5-sonnet-20241022",
+            tools=[mock_computer]
+        )
+        
+        # Verify agent accepted the tool
+        assert agent is not None
+        assert hasattr(agent, "tools")
diff --git a/libs/python/computer-server/tests/__init__.py b/libs/python/computer-server/tests/__init__.py
new file mode 100644
index 00000000..42fe8f98
--- /dev/null
+++ b/libs/python/computer-server/tests/__init__.py
@@ -0,0 +1 @@
+"""Unit tests for cua-computer-server package."""
diff --git a/libs/python/computer-server/tests/conftest.py b/libs/python/computer-server/tests/conftest.py
new file mode 100644
index 00000000..a91439c6
--- /dev/null
+++ b/libs/python/computer-server/tests/conftest.py
@@ -0,0 +1,46 @@
+"""Pytest configuration and shared fixtures for computer-server package tests.
+
+This file contains shared fixtures and configuration for all computer-server tests.
+Following SRP: This file ONLY handles test setup/teardown.
+"""
+
+import pytest
+from unittest.mock import Mock, AsyncMock, patch
+
+
+@pytest.fixture
+def mock_websocket():
+    """Mock WebSocket connection for testing.
+    
+    Use this fixture to test WebSocket logic without real connections.
+    """
+    websocket = AsyncMock()
+    websocket.send = AsyncMock()
+    websocket.recv = AsyncMock()
+    websocket.close = AsyncMock()
+    
+    return websocket
+
+
+@pytest.fixture
+def mock_computer_interface():
+    """Mock computer interface for server tests.
+    
+    Use this fixture to test server logic without real computer operations.
+    """
+    interface = AsyncMock()
+    interface.screenshot = AsyncMock(return_value=b"fake_screenshot")
+    interface.left_click = AsyncMock()
+    interface.type = AsyncMock()
+    interface.key = AsyncMock()
+    
+    return interface
+
+
+@pytest.fixture
+def disable_telemetry(monkeypatch):
+    """Disable telemetry for tests.
+    
+    Use this fixture to ensure no telemetry is sent during tests.
+    """
+    monkeypatch.setenv("CUA_TELEMETRY_DISABLED", "1")
diff --git a/libs/python/computer-server/tests/test_server.py b/libs/python/computer-server/tests/test_server.py
new file mode 100644
index 00000000..9dee291f
--- /dev/null
+++ b/libs/python/computer-server/tests/test_server.py
@@ -0,0 +1,37 @@
+"""Unit tests for computer-server package.
+
+This file tests ONLY basic server functionality.
+Following SRP: This file tests server initialization and basic operations.
+All external dependencies are mocked.
+"""
+
+import pytest
+from unittest.mock import Mock, AsyncMock, patch
+
+
+class TestServerImports:
+    """Test server module imports (SRP: Only tests imports)."""
+
+    def test_server_module_exists(self):
+        """Test that server module can be imported."""
+        try:
+            import computer_server
+            assert computer_server is not None
+        except ImportError:
+            pytest.skip("computer_server module not installed")
+
+
+class TestServerInitialization:
+    """Test server initialization (SRP: Only tests initialization)."""
+
+    @pytest.mark.asyncio
+    async def test_server_can_be_imported(self):
+        """Basic smoke test: verify server components can be imported."""
+        try:
+            from computer_server import server
+            assert server is not None
+        except ImportError:
+            pytest.skip("Server module not available")
+        except Exception as e:
+            # Some initialization errors are acceptable in unit tests
+            pytest.skip(f"Server initialization requires specific setup: {e}")
diff --git a/libs/python/computer/tests/__init__.py b/libs/python/computer/tests/__init__.py
new file mode 100644
index 00000000..9543232f
--- /dev/null
+++ b/libs/python/computer/tests/__init__.py
@@ -0,0 +1 @@
+"""Unit tests for cua-computer package."""
diff --git a/libs/python/computer/tests/conftest.py b/libs/python/computer/tests/conftest.py
new file mode 100644
index 00000000..f067c119
--- /dev/null
+++ b/libs/python/computer/tests/conftest.py
@@ -0,0 +1,68 @@
+"""Pytest configuration and shared fixtures for computer package tests.
+
+This file contains shared fixtures and configuration for all computer tests.
+Following SRP: This file ONLY handles test setup/teardown.
+"""
+
+import pytest
+from unittest.mock import Mock, AsyncMock, patch, MagicMock
+
+
+@pytest.fixture
+def mock_interface():
+    """Mock computer interface for testing.
+    
+    Use this fixture to test Computer logic without real OS calls.
+    """
+    interface = AsyncMock()
+    interface.screenshot = AsyncMock(return_value=b"fake_screenshot")
+    interface.left_click = AsyncMock()
+    interface.right_click = AsyncMock()
+    interface.middle_click = AsyncMock()
+    interface.double_click = AsyncMock()
+    interface.type = AsyncMock()
+    interface.key = AsyncMock()
+    interface.move_mouse = AsyncMock()
+    interface.scroll = AsyncMock()
+    interface.get_screen_size = AsyncMock(return_value=(1920, 1080))
+    
+    return interface
+
+
+@pytest.fixture
+def mock_cloud_provider():
+    """Mock cloud provider for testing.
+    
+    Use this fixture to test cloud provider logic without real API calls.
+    """
+    provider = AsyncMock()
+    provider.start = AsyncMock()
+    provider.stop = AsyncMock()
+    provider.get_status = AsyncMock(return_value="running")
+    provider.execute_command = AsyncMock(return_value="command output")
+    
+    return provider
+
+
+@pytest.fixture
+def mock_local_provider():
+    """Mock local provider for testing.
+    
+    Use this fixture to test local provider logic without real VM operations.
+    """
+    provider = AsyncMock()
+    provider.start = AsyncMock()
+    provider.stop = AsyncMock()
+    provider.get_status = AsyncMock(return_value="running")
+    provider.execute_command = AsyncMock(return_value="command output")
+    
+    return provider
+
+
+@pytest.fixture
+def disable_telemetry(monkeypatch):
+    """Disable telemetry for tests.
+    
+    Use this fixture to ensure no telemetry is sent during tests.
+    """
+    monkeypatch.setenv("CUA_TELEMETRY_DISABLED", "1")
diff --git a/libs/python/computer/tests/test_computer.py b/libs/python/computer/tests/test_computer.py
new file mode 100644
index 00000000..401a58e0
--- /dev/null
+++ b/libs/python/computer/tests/test_computer.py
@@ -0,0 +1,135 @@
+"""Unit tests for Computer class.
+
+This file tests ONLY the Computer class initialization and context manager.
+Following SRP: This file tests ONE class (Computer).
+All external dependencies (providers, interfaces) are mocked.
+"""
+
+import pytest
+from unittest.mock import Mock, AsyncMock, patch, MagicMock
+
+
+class TestComputerImport:
+    """Test Computer module imports (SRP: Only tests imports)."""
+
+    def test_computer_class_exists(self):
+        """Test that Computer class can be imported."""
+        from computer import Computer
+        
+        assert Computer is not None
+
+    def test_vm_provider_type_exists(self):
+        """Test that VMProviderType enum can be imported."""
+        from computer import VMProviderType
+        
+        assert VMProviderType is not None
+
+
+class TestComputerInitialization:
+    """Test Computer initialization (SRP: Only tests initialization)."""
+
+    @patch("computer.computer.LocalProvider")
+    @patch("computer.computer.Interface")
+    def test_computer_initialization_with_defaults(self, mock_interface, mock_provider, disable_telemetry):
+        """Test that Computer can be initialized with default parameters."""
+        from computer import Computer
+        
+        computer = Computer()
+        
+        assert computer is not None
+
+    @patch("computer.computer.CloudProvider")
+    @patch("computer.computer.Interface")
+    def test_computer_initialization_with_cloud_provider(self, mock_interface, mock_provider, disable_telemetry):
+        """Test that Computer can be initialized with cloud provider."""
+        from computer import Computer
+        
+        computer = Computer(
+            provider_type="cloud",
+            api_key="test-api-key"
+        )
+        
+        assert computer is not None
+
+    @patch("computer.computer.LocalProvider")
+    @patch("computer.computer.Interface")
+    def test_computer_initialization_with_os_type(self, mock_interface, mock_provider, disable_telemetry):
+        """Test that Computer can be initialized with specific OS type."""
+        from computer import Computer
+        
+        computer = Computer(os_type="linux")
+        
+        assert computer is not None
+
+
+class TestComputerContextManager:
+    """Test Computer context manager protocol (SRP: Only tests context manager)."""
+
+    @pytest.mark.asyncio
+    @patch("computer.computer.LocalProvider")
+    @patch("computer.computer.Interface")
+    async def test_computer_async_context_manager(self, mock_interface, mock_provider, disable_telemetry):
+        """Test that Computer works as async context manager."""
+        from computer import Computer
+        
+        # Mock provider
+        mock_provider_instance = AsyncMock()
+        mock_provider_instance.start = AsyncMock()
+        mock_provider_instance.stop = AsyncMock()
+        mock_provider.return_value = mock_provider_instance
+        
+        # Mock interface
+        mock_interface_instance = AsyncMock()
+        mock_interface.return_value = mock_interface_instance
+        
+        async with Computer() as computer:
+            assert computer is not None
+            assert hasattr(computer, "interface")
+
+    @pytest.mark.asyncio
+    @patch("computer.computer.LocalProvider")
+    @patch("computer.computer.Interface")
+    async def test_computer_cleanup_on_exit(self, mock_interface, mock_provider, disable_telemetry):
+        """Test that Computer cleans up resources on exit."""
+        from computer import Computer
+        
+        # Mock provider
+        mock_provider_instance = AsyncMock()
+        mock_provider_instance.start = AsyncMock()
+        mock_provider_instance.stop = AsyncMock()
+        mock_provider.return_value = mock_provider_instance
+        
+        # Mock interface
+        mock_interface_instance = AsyncMock()
+        mock_interface.return_value = mock_interface_instance
+        
+        async with Computer() as computer:
+            pass
+        
+        # Provider stop should be called on exit
+        mock_provider_instance.stop.assert_called_once()
+
+
+class TestComputerInterface:
+    """Test Computer.interface property (SRP: Only tests interface access)."""
+
+    @pytest.mark.asyncio
+    @patch("computer.computer.LocalProvider")
+    @patch("computer.computer.Interface")
+    async def test_computer_has_interface(self, mock_interface, mock_provider, disable_telemetry):
+        """Test that Computer exposes an interface property."""
+        from computer import Computer
+        
+        # Mock provider
+        mock_provider_instance = AsyncMock()
+        mock_provider_instance.start = AsyncMock()
+        mock_provider_instance.stop = AsyncMock()
+        mock_provider.return_value = mock_provider_instance
+        
+        # Mock interface
+        mock_interface_instance = AsyncMock()
+        mock_interface.return_value = mock_interface_instance
+        
+        async with Computer() as computer:
+            assert hasattr(computer, "interface")
+            assert computer.interface is not None
diff --git a/libs/python/core/tests/__init__.py b/libs/python/core/tests/__init__.py
new file mode 100644
index 00000000..e992ab29
--- /dev/null
+++ b/libs/python/core/tests/__init__.py
@@ -0,0 +1 @@
+"""Unit tests for cua-core package."""
diff --git a/libs/python/core/tests/conftest.py b/libs/python/core/tests/conftest.py
new file mode 100644
index 00000000..514801f6
--- /dev/null
+++ b/libs/python/core/tests/conftest.py
@@ -0,0 +1,42 @@
+"""Pytest configuration and shared fixtures for core package tests.
+
+This file contains shared fixtures and configuration for all core tests.
+Following SRP: This file ONLY handles test setup/teardown.
+"""
+
+import pytest
+from unittest.mock import Mock, AsyncMock, patch
+
+
+@pytest.fixture
+def mock_httpx_client():
+    """Mock httpx.AsyncClient for API calls.
+    
+    Use this fixture to avoid making real HTTP requests during tests.
+    """
+    with patch("httpx.AsyncClient") as mock_client:
+        mock_instance = AsyncMock()
+        mock_client.return_value.__aenter__.return_value = mock_instance
+        yield mock_instance
+
+
+@pytest.fixture
+def mock_posthog():
+    """Mock PostHog client for telemetry tests.
+    
+    Use this fixture to avoid sending real telemetry during tests.
+    """
+    with patch("posthog.Posthog") as mock_ph:
+        mock_instance = Mock()
+        mock_ph.return_value = mock_instance
+        yield mock_instance
+
+
+@pytest.fixture
+def disable_telemetry(monkeypatch):
+    """Disable telemetry for tests that don't need it.
+    
+    Use this fixture to ensure telemetry is disabled during tests.
+    """
+    monkeypatch.setenv("CUA_TELEMETRY_DISABLED", "1")
+    yield
diff --git a/libs/python/core/tests/test_telemetry.py b/libs/python/core/tests/test_telemetry.py
new file mode 100644
index 00000000..97a0cdc0
--- /dev/null
+++ b/libs/python/core/tests/test_telemetry.py
@@ -0,0 +1,254 @@
+"""Unit tests for core telemetry functionality.
+
+This file tests ONLY telemetry logic, following SRP.
+All external dependencies (PostHog, file system) are mocked.
+"""
+
+import os
+import pytest
+from unittest.mock import Mock, patch, MagicMock, mock_open
+from pathlib import Path
+
+
+class TestTelemetryEnabled:
+    """Test telemetry enable/disable logic (SRP: Only tests enable/disable)."""
+
+    def test_telemetry_enabled_by_default(self, monkeypatch):
+        """Test that telemetry is enabled by default."""
+        # Remove any environment variables that might affect the test
+        monkeypatch.delenv("CUA_TELEMETRY", raising=False)
+        monkeypatch.delenv("CUA_TELEMETRY_ENABLED", raising=False)
+        
+        from core.telemetry import is_telemetry_enabled
+        
+        assert is_telemetry_enabled() is True
+
+    def test_telemetry_disabled_with_legacy_flag(self, monkeypatch):
+        """Test that telemetry can be disabled with legacy CUA_TELEMETRY=off."""
+        monkeypatch.setenv("CUA_TELEMETRY", "off")
+        
+        from core.telemetry import is_telemetry_enabled
+        
+        assert is_telemetry_enabled() is False
+
+    def test_telemetry_disabled_with_new_flag(self, monkeypatch):
+        """Test that telemetry can be disabled with CUA_TELEMETRY_ENABLED=false."""
+        monkeypatch.setenv("CUA_TELEMETRY_ENABLED", "false")
+        
+        from core.telemetry import is_telemetry_enabled
+        
+        assert is_telemetry_enabled() is False
+
+    @pytest.mark.parametrize("value", ["0", "false", "no", "off"])
+    def test_telemetry_disabled_with_various_values(self, monkeypatch, value):
+        """Test that telemetry respects various disable values."""
+        monkeypatch.setenv("CUA_TELEMETRY_ENABLED", value)
+        
+        from core.telemetry import is_telemetry_enabled
+        
+        assert is_telemetry_enabled() is False
+
+    @pytest.mark.parametrize("value", ["1", "true", "yes", "on"])
+    def test_telemetry_enabled_with_various_values(self, monkeypatch, value):
+        """Test that telemetry respects various enable values."""
+        monkeypatch.setenv("CUA_TELEMETRY_ENABLED", value)
+        
+        from core.telemetry import is_telemetry_enabled
+        
+        assert is_telemetry_enabled() is True
+
+
+class TestPostHogTelemetryClient:
+    """Test PostHogTelemetryClient class (SRP: Only tests client logic)."""
+
+    @patch("core.telemetry.posthog.posthog")
+    @patch("core.telemetry.posthog.Path")
+    def test_client_initialization(self, mock_path, mock_posthog, disable_telemetry):
+        """Test that client initializes correctly."""
+        from core.telemetry.posthog import PostHogTelemetryClient
+        
+        # Mock the storage directory
+        mock_storage_dir = MagicMock()
+        mock_storage_dir.exists.return_value = False
+        mock_path.return_value.parent.parent = MagicMock()
+        mock_path.return_value.parent.parent.__truediv__.return_value = mock_storage_dir
+        
+        # Reset singleton
+        PostHogTelemetryClient.destroy_client()
+        
+        client = PostHogTelemetryClient()
+        
+        assert client is not None
+        assert hasattr(client, "installation_id")
+        assert hasattr(client, "initialized")
+        assert hasattr(client, "queued_events")
+
+    @patch("core.telemetry.posthog.posthog")
+    @patch("core.telemetry.posthog.Path")
+    def test_installation_id_generation(self, mock_path, mock_posthog, disable_telemetry):
+        """Test that installation ID is generated if not exists."""
+        from core.telemetry.posthog import PostHogTelemetryClient
+        
+        # Mock file system
+        mock_id_file = MagicMock()
+        mock_id_file.exists.return_value = False
+        mock_storage_dir = MagicMock()
+        mock_storage_dir.__truediv__.return_value = mock_id_file
+        
+        mock_core_dir = MagicMock()
+        mock_core_dir.__truediv__.return_value = mock_storage_dir
+        mock_path.return_value.parent.parent = mock_core_dir
+        
+        # Reset singleton
+        PostHogTelemetryClient.destroy_client()
+        
+        client = PostHogTelemetryClient()
+        
+        # Should have generated a new UUID
+        assert client.installation_id is not None
+        assert len(client.installation_id) == 36  # UUID format
+
+    @patch("core.telemetry.posthog.posthog")
+    @patch("core.telemetry.posthog.Path")
+    def test_installation_id_persistence(self, mock_path, mock_posthog, disable_telemetry):
+        """Test that installation ID is read from file if exists."""
+        from core.telemetry.posthog import PostHogTelemetryClient
+        
+        existing_id = "test-installation-id-123"
+        
+        # Mock file system
+        mock_id_file = MagicMock()
+        mock_id_file.exists.return_value = True
+        mock_id_file.read_text.return_value = existing_id
+        
+        mock_storage_dir = MagicMock()
+        mock_storage_dir.__truediv__.return_value = mock_id_file
+        
+        mock_core_dir = MagicMock()
+        mock_core_dir.__truediv__.return_value = mock_storage_dir
+        mock_path.return_value.parent.parent = mock_core_dir
+        
+        # Reset singleton
+        PostHogTelemetryClient.destroy_client()
+        
+        client = PostHogTelemetryClient()
+        
+        assert client.installation_id == existing_id
+
+    @patch("core.telemetry.posthog.posthog")
+    @patch("core.telemetry.posthog.Path")
+    def test_record_event_when_disabled(self, mock_path, mock_posthog, monkeypatch):
+        """Test that events are not recorded when telemetry is disabled."""
+        from core.telemetry.posthog import PostHogTelemetryClient
+        
+        # Disable telemetry explicitly using the correct environment variable
+        monkeypatch.setenv("CUA_TELEMETRY_ENABLED", "false")
+        
+        # Mock file system
+        mock_storage_dir = MagicMock()
+        mock_storage_dir.exists.return_value = False
+        mock_path.return_value.parent.parent = MagicMock()
+        mock_path.return_value.parent.parent.__truediv__.return_value = mock_storage_dir
+        
+        # Reset singleton
+        PostHogTelemetryClient.destroy_client()
+        
+        client = PostHogTelemetryClient()
+        client.record_event("test_event", {"key": "value"})
+        
+        # PostHog capture should not be called at all when telemetry is disabled
+        mock_posthog.capture.assert_not_called()
+
+    @patch("core.telemetry.posthog.posthog")
+    @patch("core.telemetry.posthog.Path")
+    def test_record_event_when_enabled(self, mock_path, mock_posthog, monkeypatch):
+        """Test that events are recorded when telemetry is enabled."""
+        from core.telemetry.posthog import PostHogTelemetryClient
+        
+        # Enable telemetry
+        monkeypatch.setenv("CUA_TELEMETRY_ENABLED", "true")
+        
+        # Mock file system
+        mock_storage_dir = MagicMock()
+        mock_storage_dir.exists.return_value = False
+        mock_path.return_value.parent.parent = MagicMock()
+        mock_path.return_value.parent.parent.__truediv__.return_value = mock_storage_dir
+        
+        # Reset singleton
+        PostHogTelemetryClient.destroy_client()
+        
+        client = PostHogTelemetryClient()
+        client.initialized = True  # Pretend it's initialized
+        
+        event_name = "test_event"
+        event_props = {"key": "value"}
+        client.record_event(event_name, event_props)
+        
+        # PostHog capture should be called
+        assert mock_posthog.capture.call_count >= 1
+
+    @patch("core.telemetry.posthog.posthog")
+    @patch("core.telemetry.posthog.Path")
+    def test_singleton_pattern(self, mock_path, mock_posthog, disable_telemetry):
+        """Test that get_client returns the same instance."""
+        from core.telemetry.posthog import PostHogTelemetryClient
+        
+        # Mock file system
+        mock_storage_dir = MagicMock()
+        mock_storage_dir.exists.return_value = False
+        mock_path.return_value.parent.parent = MagicMock()
+        mock_path.return_value.parent.parent.__truediv__.return_value = mock_storage_dir
+        
+        # Reset singleton
+        PostHogTelemetryClient.destroy_client()
+        
+        client1 = PostHogTelemetryClient.get_client()
+        client2 = PostHogTelemetryClient.get_client()
+        
+        assert client1 is client2
+
+
+class TestRecordEvent:
+    """Test the public record_event function (SRP: Only tests public API)."""
+
+    @patch("core.telemetry.posthog.PostHogTelemetryClient")
+    def test_record_event_calls_client(self, mock_client_class, disable_telemetry):
+        """Test that record_event delegates to the client."""
+        from core.telemetry import record_event
+        
+        mock_client_instance = Mock()
+        mock_client_class.get_client.return_value = mock_client_instance
+        
+        event_name = "test_event"
+        event_props = {"key": "value"}
+        
+        record_event(event_name, event_props)
+        
+        mock_client_instance.record_event.assert_called_once_with(event_name, event_props)
+
+    @patch("core.telemetry.posthog.PostHogTelemetryClient")
+    def test_record_event_without_properties(self, mock_client_class, disable_telemetry):
+        """Test that record_event works without properties."""
+        from core.telemetry import record_event
+        
+        mock_client_instance = Mock()
+        mock_client_class.get_client.return_value = mock_client_instance
+        
+        event_name = "test_event"
+        
+        record_event(event_name)
+        
+        mock_client_instance.record_event.assert_called_once_with(event_name, {})
+
+
+class TestDestroyTelemetryClient:
+    """Test client destruction (SRP: Only tests cleanup)."""
+
+    @patch("core.telemetry.posthog.PostHogTelemetryClient")
+    def test_destroy_client_calls_class_method(self, mock_client_class):
+        """Test that destroy_telemetry_client delegates correctly."""
+        from core.telemetry import destroy_telemetry_client
+        
+        destroy_telemetry_client()
+        
+        mock_client_class.destroy_client.assert_called_once()
diff --git a/libs/python/mcp-server/tests/__init__.py b/libs/python/mcp-server/tests/__init__.py
new file mode 100644
index 00000000..3bb97e04
--- /dev/null
+++ b/libs/python/mcp-server/tests/__init__.py
@@ -0,0 +1 @@
+"""Unit tests for cua-mcp-server package."""
diff --git a/libs/python/mcp-server/tests/conftest.py b/libs/python/mcp-server/tests/conftest.py
new file mode 100644
index 00000000..694d0766
--- /dev/null
+++ b/libs/python/mcp-server/tests/conftest.py
@@ -0,0 +1,50 @@
+"""Pytest configuration and shared fixtures for mcp-server package tests.
+
+This file contains shared fixtures and configuration for all mcp-server tests.
+Following SRP: This file ONLY handles test setup/teardown.
+"""
+
+import pytest
+from unittest.mock import Mock, AsyncMock, patch
+
+
+@pytest.fixture
+def mock_mcp_context():
+    """Mock MCP context for testing.
+    
+    Use this fixture to test MCP server logic without real MCP connections.
+    """
+    context = AsyncMock()
+    context.request_context = AsyncMock()
+    context.session = Mock()
+    context.session.send_resource_updated = AsyncMock()
+    
+    return context
+
+
+@pytest.fixture
+def mock_computer():
+    """Mock Computer instance for MCP server tests.
+    
+    Use this fixture to test MCP logic without real Computer operations.
+    """
+    computer = AsyncMock()
+    computer.interface = AsyncMock()
+    computer.interface.screenshot = AsyncMock(return_value=b"fake_screenshot")
+    computer.interface.left_click = AsyncMock()
+    computer.interface.type = AsyncMock()
+    
+    # Mock context manager
+    computer.__aenter__ = AsyncMock(return_value=computer)
+    computer.__aexit__ = AsyncMock()
+    
+    return computer
+
+
+@pytest.fixture
+def disable_telemetry(monkeypatch):
+    """Disable telemetry for tests.
+    
+    Use this fixture to ensure no telemetry is sent during tests.
+    """
+    monkeypatch.setenv("CUA_TELEMETRY_DISABLED", "1")
diff --git a/libs/python/mcp-server/tests/test_mcp_server.py b/libs/python/mcp-server/tests/test_mcp_server.py
new file mode 100644
index 00000000..d9fbf7bd
--- /dev/null
+++ b/libs/python/mcp-server/tests/test_mcp_server.py
@@ -0,0 +1,37 @@
+"""Unit tests for mcp-server package.
+
+This file tests ONLY basic MCP server functionality.
+Following SRP: This file tests MCP server initialization.
+All external dependencies are mocked.
+"""
+
+import pytest
+from unittest.mock import Mock, AsyncMock, patch
+
+
+class TestMCPServerImports:
+    """Test MCP server module imports (SRP: Only tests imports)."""
+
+    def test_mcp_server_module_exists(self):
+        """Test that mcp_server module can be imported."""
+        try:
+            import mcp_server
+            assert mcp_server is not None
+        except ImportError:
+            pytest.skip("mcp_server module not installed")
+
+
+class TestMCPServerInitialization:
+    """Test MCP server initialization (SRP: Only tests initialization)."""
+
+    @pytest.mark.asyncio
+    async def test_mcp_server_can_be_imported(self):
+        """Basic smoke test: verify MCP server components can be imported."""
+        try:
+            from mcp_server import server
+            assert server is not None
+        except ImportError:
+            pytest.skip("MCP server module not available")
+        except Exception as e:
+            # Some initialization errors are acceptable in unit tests
+            pytest.skip(f"MCP server initialization requires specific setup: {e}")
diff --git a/libs/python/pylume/tests/__init__.py b/libs/python/pylume/tests/__init__.py
new file mode 100644
index 00000000..6e2698b3
--- /dev/null
+++ b/libs/python/pylume/tests/__init__.py
@@ -0,0 +1 @@
+"""Unit tests for pylume package."""
diff --git a/libs/python/pylume/tests/conftest.py b/libs/python/pylume/tests/conftest.py
new file mode 100644
index 00000000..d32b5680
--- /dev/null
+++ b/libs/python/pylume/tests/conftest.py
@@ -0,0 +1,47 @@
+"""Pytest configuration and shared fixtures for pylume package tests.
+
+This file contains shared fixtures and configuration for all pylume tests.
+Following SRP: This file ONLY handles test setup/teardown.
+"""
+
+import pytest
+from unittest.mock import Mock, AsyncMock, patch
+
+
+@pytest.fixture
+def mock_subprocess():
+    """Mock subprocess calls for testing.
+    
+    Use this fixture to test command execution without running real commands.
+    """
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = Mock(
+            returncode=0,
+            stdout="mocked output",
+            stderr=""
+        )
+        yield mock_run
+
+
+@pytest.fixture
+def mock_lume_cli():
+    """Mock Lume CLI interactions.
+    
+    Use this fixture to test Lume integration without real VM operations.
+    """
+    with patch("pylume.lume.LumeClient") as mock_client:
+        mock_instance = Mock()
+        mock_instance.list_vms = Mock(return_value=[])
+        mock_instance.create_vm = Mock(return_value={"id": "test-vm-123"})
+        mock_instance.delete_vm = Mock(return_value=True)
+        mock_client.return_value = mock_instance
+        yield mock_instance
+
+
+@pytest.fixture
+def disable_telemetry(monkeypatch):
+    """Disable telemetry for tests.
+    
+    Use this fixture to ensure no telemetry is sent during tests.
+    """
+    monkeypatch.setenv("CUA_TELEMETRY_DISABLED", "1")
diff --git a/libs/python/pylume/tests/test_pylume.py b/libs/python/pylume/tests/test_pylume.py
new file mode 100644
index 00000000..58af450d
--- /dev/null
+++ b/libs/python/pylume/tests/test_pylume.py
@@ -0,0 +1,37 @@
+"""Unit tests for pylume package.
+
+This file tests ONLY basic pylume functionality.
+Following SRP: This file tests pylume module imports and basic operations.
+All external dependencies are mocked.
+"""
+
+import pytest
+from unittest.mock import Mock, AsyncMock, patch
+
+
+class TestPylumeImports:
+    """Test pylume module imports (SRP: Only tests imports)."""
+
+    def test_pylume_module_exists(self):
+        """Test that pylume module can be imported."""
+        try:
+            import pylume
+            assert pylume is not None
+        except ImportError:
+            pytest.skip("pylume module not installed")
+
+
+class TestPylumeInitialization:
+    """Test pylume initialization (SRP: Only tests initialization)."""
+
+    def test_pylume_can_be_imported(self):
+        """Basic smoke test: verify pylume components can be imported."""
+        try:
+            import pylume
+            # Check for basic attributes
+            assert pylume is not None
+        except ImportError:
+            pytest.skip("pylume module not available")
+        except Exception as e:
+            # Some initialization errors are acceptable in unit tests
+            pytest.skip(f"pylume initialization requires specific setup: {e}")