diff --git a/src/praisonai/tests/_pytest_plugins/test_gating.py b/src/praisonai/tests/_pytest_plugins/test_gating.py
index 9d970121a..3b771893a 100644
--- a/src/praisonai/tests/_pytest_plugins/test_gating.py
+++ b/src/praisonai/tests/_pytest_plugins/test_gating.py
@@ -206,7 +206,7 @@ def pytest_collection_modifyitems(config, items):
         
         # 2. Auto-detect and assign provider markers from file content
         # Skip auto-detection entirely for excluded paths (plugin tests, etc.)
-        if item.fspath:
+        if item.fspath and test_type != 'unit':
             filepath = Path(item.fspath)
             filepath_str = str(filepath)
             
diff --git a/src/praisonai/tests/integration/README.md b/src/praisonai/tests/integration/README.md
index 720c0a0bb..2d9df7dea 100644
--- a/src/praisonai/tests/integration/README.md
+++ b/src/praisonai/tests/integration/README.md
@@ -16,9 +16,45 @@ tests/integration/
 │   └── test_crewai_basic.py     # Basic CrewAI integration tests
 ├── test_base_url_api_base_fix.py # API base URL integration tests
 ├── test_mcp_integration.py      # Model Context Protocol tests
+├── test_managed_real.py         # Real agentic managed agent tests
 └── test_rag_integration.py      # RAG (Retrieval Augmented Generation) tests
 ```
 
+## Real Agentic Tests
+
+### Managed Agents Integration Tests
+Located in `test_managed_real.py`
+
+**IMPORTANT:** These tests make actual LLM API calls and are gated by environment variables.
+
+**Test Coverage:**
+- ✅ Anthropic managed agents with claude-haiku-4-5
+- ✅ Local managed agents with gpt-4o-mini
+- ✅ Multi-turn session persistence
+- ✅ Tool execution in managed environments
+- ✅ Streaming functionality
+- ✅ Usage token tracking
+- ✅ Session ID generation and persistence
+
+**Environment Variables:**
+- `RUN_REAL_AGENTIC=1` - Required to enable these tests
+- `ANTHROPIC_API_KEY` - Required for Anthropic managed agent tests
+- `OPENAI_API_KEY` - Required for local managed agent tests
+
+**Example Usage:**
+```bash
+# Run all real agentic tests (requires API keys)
+RUN_REAL_AGENTIC=1 pytest src/praisonai/tests/integration/test_managed_real.py -v
+
+# Run only Anthropic tests
+RUN_REAL_AGENTIC=1 PRAISONAI_TEST_PROVIDERS=anthropic pytest src/praisonai/tests/integration/test_managed_real.py::test_anthropic_managed_real -v
+
+# Run only local/OpenAI tests
+RUN_REAL_AGENTIC=1 PRAISONAI_TEST_PROVIDERS=openai pytest src/praisonai/tests/integration/test_managed_real.py::test_local_managed_real_openai -v
+```
+
+**Expected Output:** Each test prints the full LLM response for human verification, along with usage statistics and session IDs.
+
 ## Framework Integration Tests
 
 ### AutoGen Integration Tests
@@ -139,6 +175,7 @@ python -m pytest tests/integration/autogen/test_autogen_basic.py::TestAutoGenInt
 ### Feature Integration Tests
 - **RAG**: Tests Retrieval Augmented Generation functionality
 - **MCP**: Tests Model Context Protocol integration
+- **Managed Agents**: Real agentic tests for managed agent backends (Anthropic & Local)
 - **Base URL/API**: Tests API base configuration and URL handling
 
 ## Test Dependencies
@@ -153,6 +190,12 @@ pip install pyautogen
 pip install crewai
 ```
 
+### Required for Managed Agent Real Tests:
+```bash
+pip install anthropic>=0.94.0  # For Anthropic managed agents
+pip install litellm>=1.81.0    # For local managed agents
+```
+
 ### Required for all integration tests:
 ```bash
 pip install pytest pytest-asyncio
@@ -160,13 +203,13 @@ pip install pytest pytest-asyncio
 
 ## Mock Strategy
 
-All integration tests use comprehensive mocking to avoid:
+Most integration tests use comprehensive mocking to avoid:
 - ❌ Real API calls (expensive and unreliable)
 - ❌ Network dependencies 
 - ❌ Rate limiting issues
 - ❌ Environment-specific failures
 
-**Mocking Pattern:**
+**Standard Mocking Pattern:**
 ```python
 @patch('litellm.completion')
 def test_framework_integration(self, mock_completion, mock_framework_completion):
@@ -174,6 +217,15 @@ def test_framework_integration(self, mock_completion, mock_framework_completion)
     # Test logic here
 ```
 
+**Exception: Real Agentic Tests**
+
+The managed agent real tests (`test_managed_real.py`) are intentionally **NOT mocked** because they are designed to verify end-to-end LLM functionality. These tests:
+- ✅ Make actual API calls to verify real behavior
+- ✅ Are gated by `RUN_REAL_AGENTIC=1` environment variable
+- ✅ Require actual API keys (ANTHROPIC_API_KEY, OPENAI_API_KEY)
+- ✅ Print full LLM responses for human verification
+- ✅ Test real token usage, session management, and tool execution
+
 ## Expected Test Outcomes
 
 ### ✅ Success Scenarios
diff --git a/src/praisonai/tests/integration/test_managed_real.py b/src/praisonai/tests/integration/test_managed_real.py
new file mode 100644
index 000000000..b35636b3e
--- /dev/null
+++ b/src/praisonai/tests/integration/test_managed_real.py
@@ -0,0 +1,365 @@
+"""
+Real Agentic Integration Tests for Managed Agents.
+
+These tests make actual LLM calls to verify end-to-end functionality.
+They are gated by environment variables and pytest markers.
+
+Gate environment variables:
+- RUN_REAL_AGENTIC=1 - enables these tests
+- ANTHROPIC_API_KEY - required for Anthropic managed agent tests  
+- OPENAI_API_KEY - required for local managed agent tests
+
+Usage:
+    # Run all real agentic tests (requires API keys)
+    RUN_REAL_AGENTIC=1 pytest src/praisonai/tests/integration/test_managed_real.py -v
+
+    # Run only Anthropic tests
+    RUN_REAL_AGENTIC=1 PRAISONAI_TEST_PROVIDERS=anthropic pytest src/praisonai/tests/integration/test_managed_real.py::test_anthropic_managed_real -v
+
+    # Run only local/OpenAI tests  
+    RUN_REAL_AGENTIC=1 PRAISONAI_TEST_PROVIDERS=openai pytest src/praisonai/tests/integration/test_managed_real.py::test_local_managed_real_openai -v
+"""
+
+import os
+import pytest
+
+
+@pytest.mark.integration
+@pytest.mark.network
+@pytest.mark.provider_anthropic 
+def test_anthropic_managed_real():
+    """Test Anthropic managed agents with real LLM calls.
+    
+    Requirements per issue #1428:
+    - Uses claude-haiku-4-5
+    - Asserts non-empty result
+    - Asserts total_input_tokens > 0
+    - Asserts non-empty session_id
+    - Prints full LLM output for human verification
+    """
+    # Gate check - skip unless explicitly enabled
+    if not os.environ.get("RUN_REAL_AGENTIC"):
+        pytest.skip("RUN_REAL_AGENTIC=1 not set - skipping real agentic test")
+        
+    # Import requirements with skipif for missing deps
+    try:
+        import anthropic
+    except ImportError:
+        pytest.skip("anthropic SDK not available - install with: pip install anthropic>=0.94.0")
+    
+    if not os.environ.get("ANTHROPIC_API_KEY") and not os.environ.get("CLAUDE_API_KEY"):
+        pytest.skip("ANTHROPIC_API_KEY or CLAUDE_API_KEY not set")
+    
+    from praisonai.integrations.managed_agents import ManagedAgent, ManagedConfig
+    from praisonaiagents import Agent
+    
+    # Create managed backend with claude-haiku-4-5
+    config = ManagedConfig(
+        model="claude-haiku-4-5",
+        system="You are a helpful assistant that provides concise answers.",
+        tools=[{"type": "agent_toolset_20260401"}]
+    )
+    
+    managed = ManagedAgent(provider="anthropic", config=config)
+    
+    # Create agent with managed backend
+    agent = Agent(
+        name="test-anthropic-managed", 
+        backend=managed
+    )
+    
+    # Execute real prompt
+    prompt = "Say hello and explain in one sentence what you are."
+    print(f"\n🔸 Executing prompt: {prompt}")
+    
+    result = agent.start(prompt)
+    
+    # Print full LLM output for human verification
+    print(f"\n✅ Full LLM Output:")
+    print("-" * 60)
+    print(result)
+    print("-" * 60)
+    
+    # Assertions per requirements
+    assert result, "Result should be non-empty"
+    assert isinstance(result, str), "Result should be a string"
+    assert len(result.strip()) > 0, "Result should contain non-whitespace content"
+    
+    # Check usage tracking
+    assert managed.total_input_tokens > 0, f"Should have input tokens, got: {managed.total_input_tokens}"
+    
+    # Check session was created  
+    assert managed.session_id, f"Should have session_id, got: {managed.session_id}"
+    assert managed.session_id.startswith("sesn_"), f"Session ID should have Anthropic format, got: {managed.session_id}"
+    
+    print(f"\n📊 Usage: input_tokens={managed.total_input_tokens}, output_tokens={managed.total_output_tokens}")
+    print(f"🆔 Session ID: {managed.session_id}")
+
+
+@pytest.mark.integration
+@pytest.mark.network
+@pytest.mark.provider_openai
+def test_local_managed_real_openai():
+    """Test local managed agents using OpenAI with real LLM calls.
+    
+    Requirements per issue #1428:
+    - Uses gpt-4o-mini
+    - Same assertions as Anthropic test
+    - Prints full LLM output for human verification
+    """
+    # Gate check - skip unless explicitly enabled
+    if not os.environ.get("RUN_REAL_AGENTIC"):
+        pytest.skip("RUN_REAL_AGENTIC=1 not set - skipping real agentic test")
+        
+    # Check for OpenAI API key
+    if not os.environ.get("OPENAI_API_KEY"):
+        pytest.skip("OPENAI_API_KEY not set")
+    
+    # Import requirements
+    try:
+        from praisonai.integrations.managed_local import LocalManagedAgent, LocalManagedConfig
+    except ImportError:
+        pytest.skip("LocalManagedAgent not available")
+    
+    from praisonaiagents import Agent
+    
+    # Create local managed backend with gpt-4o-mini
+    config = LocalManagedConfig(
+        model="gpt-4o-mini",
+        system="You are a helpful assistant that provides concise answers.",
+        tools=["execute_command", "read_file", "write_file"]  # Local tool format
+    )
+    
+    managed = LocalManagedAgent(provider="openai", config=config)
+    
+    # Create agent with managed backend
+    agent = Agent(
+        name="test-local-openai-managed",
+        backend=managed
+    )
+    
+    # Execute real prompt  
+    prompt = "Say hello and explain in one sentence what you are."
+    print(f"\n🔸 Executing prompt: {prompt}")
+    
+    result = agent.start(prompt)
+    
+    # Print full LLM output for human verification
+    print(f"\n✅ Full LLM Output:")
+    print("-" * 60) 
+    print(result)
+    print("-" * 60)
+    
+    # Assertions per requirements
+    assert result, "Result should be non-empty"
+    assert isinstance(result, str), "Result should be a string"
+    assert len(result.strip()) > 0, "Result should contain non-whitespace content"
+    
+    # Check usage tracking (local managed may or may not track)
+    if hasattr(managed, 'total_input_tokens'):
+        print(f"📊 Usage: input_tokens={managed.total_input_tokens}, output_tokens={managed.total_output_tokens}")
+    
+    # Check session was created
+    assert managed.session_id, f"Should have session_id, got: {managed.session_id}"
+    
+    print(f"🆔 Session ID: {managed.session_id}")
+
+
+@pytest.mark.integration 
+@pytest.mark.network
+@pytest.mark.provider_anthropic
+def test_multi_turn_preserves_session():
+    """Test that multiple turns preserve the same session ID.
+    
+    Requirements per issue #1428:
+    - Two calls keep same session id
+    """
+    # Gate check - skip unless explicitly enabled
+    if not os.environ.get("RUN_REAL_AGENTIC"):
+        pytest.skip("RUN_REAL_AGENTIC=1 not set - skipping real agentic test")
+        
+    # Import requirements with skipif for missing deps
+    try:
+        import anthropic
+    except ImportError:
+        pytest.skip("anthropic SDK not available")
+    
+    if not os.environ.get("ANTHROPIC_API_KEY") and not os.environ.get("CLAUDE_API_KEY"):
+        pytest.skip("ANTHROPIC_API_KEY or CLAUDE_API_KEY not set")
+    
+    from praisonai.integrations.managed_agents import ManagedAgent, ManagedConfig
+    from praisonaiagents import Agent
+    
+    # Create managed backend
+    config = ManagedConfig(
+        model="claude-haiku-4-5",
+        system="You are a helpful assistant. Remember previous interactions.",
+    )
+    
+    managed = ManagedAgent(provider="anthropic", config=config)
+    
+    # Create agent with managed backend
+    agent = Agent(
+        name="test-session-persistence",
+        backend=managed
+    )
+    
+    # First turn
+    print(f"\n🔸 First turn...")
+    result1 = agent.start("Hi, I'm Alice. Please remember my name.")
+    session_id_1 = managed.session_id
+    
+    print(f"Turn 1 result: {result1}")
+    print(f"Session ID after turn 1: {session_id_1}")
+    
+    # Second turn - should preserve session
+    print(f"\n🔸 Second turn...")
+    result2 = agent.start("What's my name?")
+    session_id_2 = managed.session_id
+    
+    print(f"Turn 2 result: {result2}")
+    print(f"Session ID after turn 2: {session_id_2}")
+    
+    # Assertions
+    assert result1, "First result should be non-empty"
+    assert result2, "Second result should be non-empty" 
+    
+    assert session_id_1 == session_id_2, f"Session IDs should match: {session_id_1} != {session_id_2}"
+    
+    # The second response should ideally remember the name "Alice"
+    # This is a best-effort check since it depends on the LLM's behavior
+    print(f"\n📋 Multi-turn test completed. Session preserved: {session_id_1}")
+
+
+@pytest.mark.integration
+@pytest.mark.network 
+@pytest.mark.provider_anthropic
+def test_anthropic_tool_execution():
+    """Test Anthropic managed agents with actual tool execution.
+    
+    Verifies that tools work end-to-end in managed environment.
+    """
+    # Gate check - skip unless explicitly enabled  
+    if not os.environ.get("RUN_REAL_AGENTIC"):
+        pytest.skip("RUN_REAL_AGENTIC=1 not set - skipping real agentic test")
+        
+    # Import requirements with skipif for missing deps
+    try:
+        import anthropic
+    except ImportError:
+        pytest.skip("anthropic SDK not available")
+    
+    if not os.environ.get("ANTHROPIC_API_KEY") and not os.environ.get("CLAUDE_API_KEY"):
+        pytest.skip("ANTHROPIC_API_KEY or CLAUDE_API_KEY not set")
+    
+    from praisonai.integrations.managed_agents import ManagedAgent, ManagedConfig
+    from praisonaiagents import Agent
+    
+    # Create managed backend with tools enabled
+    config = ManagedConfig(
+        model="claude-haiku-4-5",
+        system="You are a helpful assistant with access to tools. Use tools when appropriate.",
+        tools=[{"type": "agent_toolset_20260401"}]  # Includes bash, file ops, etc
+    )
+    
+    managed = ManagedAgent(provider="anthropic", config=config)
+    
+    # Create agent with managed backend
+    agent = Agent(
+        name="test-tool-execution",
+        backend=managed
+    )
+    
+    # Execute prompt that should trigger tool use
+    prompt = "Please create a simple Python file called hello.py that prints 'Hello from managed agent!' and then run it."
+    print(f"\n🔸 Executing tool prompt: {prompt}")
+    
+    result = agent.start(prompt)
+    
+    # Print full output for human verification
+    print(f"\n✅ Tool Execution Output:")
+    print("-" * 60)
+    print(result)
+    print("-" * 60)
+    
+    # Assertions
+    assert result, "Result should be non-empty"
+    assert managed.session_id, "Should have session_id"
+    assert managed.total_input_tokens > 0, "Should have tracked input tokens"
+    
+    # Best-effort check that tools were likely used  
+    # (The exact output depends on the LLM's behavior)
+    result_lower = result.lower()
+    tool_indicators = ["file", "create", "run", "python", "hello", "executed", "output"]
+    
+    found_indicators = [indicator for indicator in tool_indicators if indicator in result_lower]
+    print(f"\n🔧 Found tool usage indicators: {found_indicators}")
+    
+    # We expect at least some tool usage indicators
+    assert len(found_indicators) >= 2, f"Expected some tool usage indicators, found: {found_indicators}"
+    
+    print(f"\n📊 Usage: input_tokens={managed.total_input_tokens}, output_tokens={managed.total_output_tokens}")
+    print(f"🆔 Session ID: {managed.session_id}")
+
+
+@pytest.mark.integration
+@pytest.mark.network
+@pytest.mark.provider_openai  
+def test_local_managed_streaming():
+    """Test streaming functionality with local managed agents.
+    
+    Verifies that streaming works correctly.
+    """
+    # Gate check - skip unless explicitly enabled
+    if not os.environ.get("RUN_REAL_AGENTIC"):
+        pytest.skip("RUN_REAL_AGENTIC=1 not set - skipping real agentic test")
+        
+    # Check for OpenAI API key
+    if not os.environ.get("OPENAI_API_KEY"):
+        pytest.skip("OPENAI_API_KEY not set")
+    
+    # Import requirements
+    try:
+        from praisonai.integrations.managed_local import LocalManagedAgent, LocalManagedConfig
+    except ImportError:
+        pytest.skip("LocalManagedAgent not available")
+    
+    import asyncio
+    
+    # Create local managed backend
+    config = LocalManagedConfig(
+        model="gpt-4o-mini",
+        system="You are a helpful assistant. Provide detailed responses.",
+    )
+    
+    managed = LocalManagedAgent(provider="openai", config=config)
+    
+    async def test_streaming():
+        # Test streaming execution
+        prompt = "Count from 1 to 5, explaining each number."
+        print(f"\n🔸 Testing streaming with prompt: {prompt}")
+        
+        chunks = []
+        async for chunk in managed.stream(prompt):
+            chunks.append(chunk)
+            print(chunk, end="", flush=True)  # Print chunks as they arrive
+        
+        full_response = "".join(chunks)
+        print(f"\n\n✅ Complete streamed response:")
+        print("-" * 60)
+        print(full_response)
+        print("-" * 60)
+        
+        # Assertions
+        assert len(chunks) > 0, "Should have received streaming chunks"
+        assert full_response.strip(), "Full response should be non-empty"
+        assert managed.session_id, "Should have session_id"
+        
+        print(f"\n📊 Received {len(chunks)} chunks")
+        print(f"🆔 Session ID: {managed.session_id}")
+        
+        return full_response
+    
+    # Run the async test
+    result = asyncio.run(test_streaming())
+    assert result, "Async streaming test should return result"
\ No newline at end of file
diff --git a/src/praisonai/tests/unit/integrations/test_managed_agents.py b/src/praisonai/tests/unit/integrations/test_managed_agents.py
index 8f59c489a..4bbf6e395 100644
--- a/src/praisonai/tests/unit/integrations/test_managed_agents.py
+++ b/src/praisonai/tests/unit/integrations/test_managed_agents.py
@@ -1,35 +1,39 @@
 """
-Unit tests for the ManagedAgentIntegration feature.
+Unit tests for the Managed Agents Integration feature.
 
 Tests the basic functionality of the managed agent backend integration
-without making actual API calls.
+without making actual API calls. Focuses on current API surface and
+protocol compliance.
 """
 
 import pytest
-from unittest.mock import Mock, patch
-
-
-def test_managed_agent_integration_import():
-    """Test that ManagedAgentIntegration can be imported."""
-    from praisonai.integrations.managed_agents import ManagedAgentIntegration
-    assert ManagedAgentIntegration is not None
-
-
-def test_managed_agent_integration_creation():
-    """Test creating a ManagedAgentIntegration instance."""
-    with patch('praisonai.integrations.managed_agents.aiohttp', None):
-        from praisonai.integrations.managed_agents import ManagedAgentIntegration
-        
-        # Should not raise an exception even without aiohttp
-        managed = ManagedAgentIntegration(
-            provider="anthropic", 
-            api_key="test_key"
-        )
-        
-        assert managed.provider == "anthropic"
-        assert managed.api_key == "test_key"
-        assert managed.cli_command == "managed-anthropic"
-        assert not managed.is_available  # Should be False without aiohttp
+from unittest.mock import Mock, patch, MagicMock
+
+
+def test_managed_config_dataclass():
+    """Test ManagedConfig dataclass creation and defaults."""
+    from praisonai.integrations.managed_agents import ManagedConfig
+    
+    # Test with defaults
+    config = ManagedConfig()
+    assert config.name == "Agent"
+    assert config.model == "claude-haiku-4-5"
+    assert config.system == "You are a helpful coding assistant."
+    assert config.tools == [{"type": "agent_toolset_20260401"}]
+    assert config.env_name == "praisonai-env"
+    assert config.networking == {"type": "unrestricted"}
+    
+    # Test with custom values
+    custom_config = ManagedConfig(
+        name="CustomAgent",
+        model="claude-sonnet-4-6",
+        system="You are a research assistant.",
+        tools=[{"type": "agent_toolset_20260401"}, {"type": "custom", "name": "my_tool"}]
+    )
+    assert custom_config.name == "CustomAgent"
+    assert custom_config.model == "claude-sonnet-4-6"
+    assert custom_config.system == "You are a research assistant."
+    assert len(custom_config.tools) == 2
 
 
 def test_tool_mapping():
@@ -43,155 +47,265 @@ def test_tool_mapping():
     assert mapped_tools == expected
 
 
-def test_agent_backend_parameter():
-    """Test that Agent class supports the backend parameter."""
-    # Mock aiohttp to avoid import issues
-    with patch('praisonai.integrations.managed_agents.aiohttp', None):
-        from praisonai.integrations.managed_agents import ManagedAgentIntegration
-        from praisonaiagents import Agent
-        
-        # Create a managed backend instance
-        managed = ManagedAgentIntegration(provider="anthropic", api_key="test_key")
-        
-        # Create agent with backend parameter
-        agent = Agent(
-            name="test_agent",
-            instructions="You are a test agent.",
-            backend=managed
-        )
-        
-        # Verify backend is stored
-        assert agent.backend == managed
-
-
-def test_agent_backend_delegation():
-    """Test that Agent properly delegates execution to backend."""
-    import asyncio
-    from typing import Dict, Any, AsyncIterator
-    
-    class MockManagedBackend:
-        """Mock backend to test delegation."""
-        
-        def __init__(self):
-            self.executed_prompts = []
-            self.execution_kwargs = []
-        
-        async def execute(self, prompt: str, **kwargs) -> str:
-            self.executed_prompts.append(prompt)
-            self.execution_kwargs.append(kwargs)
-            return f"Backend response: {prompt}"
-        
-        async def stream(self, prompt: str, **kwargs) -> AsyncIterator[Dict[str, Any]]:
-            self.executed_prompts.append(prompt)
-            self.execution_kwargs.append(kwargs)
-            yield {
-                'type': 'agent.message',
-                'content': [{'type': 'text', 'text': f"Backend streamed: {prompt}"}]
-            }
-    
-    # Create mock backend
-    mock_backend = MockManagedBackend()
+def test_managed_agent_factory_auto_detection():
+    """Test ManagedAgent factory auto-detection logic."""
+    from praisonai.integrations.managed_agents import ManagedAgent
+    
+    # Test auto-detection with no env vars (should default to local)
+    with patch.dict('os.environ', {}, clear=True):
+        managed = ManagedAgent()
+        assert managed.provider == "local"
+    
+    # Test auto-detection with ANTHROPIC_API_KEY
+    with patch.dict('os.environ', {'ANTHROPIC_API_KEY': 'test-key'}, clear=True):
+        managed = ManagedAgent()
+        assert managed.provider == "anthropic"
+        assert managed.api_key == "test-key"
+    
+    # Test auto-detection with CLAUDE_API_KEY
+    with patch.dict('os.environ', {'CLAUDE_API_KEY': 'claude-key'}, clear=True):
+        managed = ManagedAgent()
+        assert managed.provider == "anthropic"
+        assert managed.api_key == "claude-key"
+
+
+def test_managed_agent_factory_explicit_providers():
+    """Test ManagedAgent factory with explicit provider selection."""
+    from praisonai.integrations.managed_agents import ManagedAgent, ManagedConfig
+    
+    # Test explicit anthropic
+    config = ManagedConfig(model="claude-haiku-4-5")
+    managed = ManagedAgent(provider="anthropic", config=config, api_key="test-key")
+    assert managed.provider == "anthropic"
+    assert managed.api_key == "test-key"
+    
+    # Test explicit local
+    managed = ManagedAgent(provider="local", config=config)
+    assert managed.provider == "local"
+    
+    # Test OpenAI routing to local
+    managed = ManagedAgent(provider="openai", config=config)
+    assert managed.provider == "openai"
+    
+    # Test Ollama routing to local
+    managed = ManagedAgent(provider="ollama", config=config)
+    assert managed.provider == "ollama"
+
+
+def test_anthropic_managed_agent_creation():
+    """Test AnthropicManagedAgent creation and configuration."""
+    from praisonai.integrations.managed_agents import AnthropicManagedAgent, ManagedConfig
+    
+    config = ManagedConfig(
+        name="TestAgent",
+        model="claude-haiku-4-5",
+        system="Test system prompt",
+        tools=[{"type": "agent_toolset_20260401"}]
+    )
+    
+    managed = AnthropicManagedAgent(
+        provider="anthropic",
+        api_key="test-key",
+        config=config,
+        timeout=120,
+        instructions="Test instructions"
+    )
+    
+    assert managed.provider == "anthropic"
+    assert managed.api_key == "test-key"
+    assert managed.timeout == 120
+    assert managed.instructions == "Test instructions"
+    assert managed._cfg["name"] == "TestAgent"
+    assert managed._cfg["model"] == "claude-haiku-4-5"
+    assert managed._cfg["system"] == "Test system prompt"
+    
+    # Check initial state
+    assert managed.agent_id is None
+    assert managed.environment_id is None
+    assert managed.session_id is None
+    assert managed.total_input_tokens == 0
+    assert managed.total_output_tokens == 0
+
+
+def test_anthropic_managed_agent_dict_config():
+    """Test AnthropicManagedAgent with dict config (backward compatibility)."""
+    from praisonai.integrations.managed_agents import AnthropicManagedAgent
+    
+    config_dict = {
+        "name": "DictAgent",
+        "model": "claude-sonnet-4-6",
+        "system": "Dict config test",
+        "tools": [{"type": "custom", "name": "test_tool"}]
+    }
+    
+    managed = AnthropicManagedAgent(config=config_dict, api_key="test-key")
+    
+    assert managed._cfg["name"] == "DictAgent"
+    assert managed._cfg["model"] == "claude-sonnet-4-6"
+    assert managed._cfg["system"] == "Dict config test"
+    assert managed._cfg["tools"] == [{"type": "custom", "name": "test_tool"}]
+
+
+def test_managed_backend_protocol_compliance():
+    """Test that managed agents implement the expected protocol methods."""
+    from praisonai.integrations.managed_agents import AnthropicManagedAgent
+    
+    managed = AnthropicManagedAgent(api_key="test-key")
+    
+    # Check protocol methods exist
+    assert hasattr(managed, 'execute')
+    assert hasattr(managed, 'stream')
+    assert hasattr(managed, 'reset_session')
+    assert hasattr(managed, 'reset_all')
+    assert hasattr(managed, 'update_agent')
+    assert hasattr(managed, 'interrupt')
+    assert hasattr(managed, 'retrieve_session')
+    assert hasattr(managed, 'list_sessions')
+    assert hasattr(managed, 'resume_session')
+    assert hasattr(managed, 'save_ids')
+    assert hasattr(managed, 'restore_ids')
+    
+    # Check properties
+    assert hasattr(managed, 'session_id')
+    assert hasattr(managed, 'managed_session_id')
+    assert managed.managed_session_id == managed.session_id
+
+
+def test_id_persistence_methods():
+    """Test save_ids and restore_ids functionality."""
+    from praisonai.integrations.managed_agents import AnthropicManagedAgent
+    
+    managed = AnthropicManagedAgent(api_key="test-key")
+    
+    # Set some test IDs
+    managed.agent_id = "agent_123"
+    managed.agent_version = 2
+    managed.environment_id = "env_456"
+    managed._session_id = "session_789"
+    
+    # Save IDs
+    saved_ids = managed.save_ids()
+    expected_ids = {
+        "agent_id": "agent_123",
+        "agent_version": 2,
+        "environment_id": "env_456",
+        "session_id": "session_789"
+    }
+    assert saved_ids == expected_ids
+    
+    # Reset and restore
+    managed.reset_all()
+    assert managed.agent_id is None
+    assert managed.session_id is None
+    
+    managed.restore_ids(saved_ids)
+    assert managed.agent_id == "agent_123"
+    assert managed.agent_version == 2
+    assert managed.environment_id == "env_456"
+    assert managed.session_id == "session_789"
+
+
+def test_session_management():
+    """Test session management methods."""
+    from praisonai.integrations.managed_agents import AnthropicManagedAgent
+    
+    managed = AnthropicManagedAgent(api_key="test-key")
+    
+    # Test initial state
+    assert managed.session_id is None
+    
+    # Test reset methods
+    managed._session_id = "test_session"
+    managed.total_input_tokens = 100
+    managed.total_output_tokens = 200
+    
+    managed.reset_session()
+    assert managed.session_id is None
+    assert managed.total_input_tokens == 100  # Should not reset tokens
+    
+    managed._session_id = "test_session"
+    managed.reset_all()
+    assert managed.session_id is None
+    assert managed.total_input_tokens == 0
+    assert managed.total_output_tokens == 0
+    assert managed.agent_id is None
+
+
+def test_agent_backend_integration():
+    """Test that Agent class can use managed backend."""
+    from praisonaiagents import Agent
+    from praisonai.integrations.managed_agents import AnthropicManagedAgent
+    
+    # Create a mock backend
+    mock_backend = Mock(spec=AnthropicManagedAgent)
+    mock_backend.execute.return_value = "Backend response"
     
     # Create agent with backend
     agent = Agent(
-        name="test-agent",
+        name="test_agent",
         instructions="Test agent",
         backend=mock_backend
     )
     
-    # Test run() delegation
-    result = agent.run("Test run prompt")
-    assert result == "Backend response: Test run prompt"
-    assert len(mock_backend.executed_prompts) == 1
-    assert mock_backend.executed_prompts[0] == "Test run prompt"
-    
-    # Test start() delegation
-    result = agent.start("Test start prompt")
-    assert result == "Backend response: Test start prompt"
-    assert len(mock_backend.executed_prompts) == 2
-    assert mock_backend.executed_prompts[1] == "Test start prompt"
-    
-    # Test chat() delegation
-    result = agent.chat("Test chat prompt")
-    assert result == "Backend response: Test chat prompt"
-    assert len(mock_backend.executed_prompts) == 3
-    assert mock_backend.executed_prompts[2] == "Test chat prompt"
-    
-    # Test that Agent without backend doesn't delegate
-    local_agent = Agent(name="local", instructions="Local agent")
-    assert not hasattr(local_agent, 'backend') or local_agent.backend is None
-
-
-def test_managed_backend_protocol():
-    """Test the ManagedBackendProtocol interface."""
-    from praisonai.integrations.managed_agents import ManagedBackendProtocol
-    
-    # Test that the protocol has the expected abstract methods
-    expected_methods = [
-        'create_agent',
-        'create_environment',
-        'create_session',
-        'send_message',
-        'stream_events',
-        'collect_response'
-    ]
-    
-    for method_name in expected_methods:
-        assert hasattr(ManagedBackendProtocol, method_name)
-
-
-@patch('praisonai.integrations.managed_agents.aiohttp')
-def test_anthropic_provider_creation(mock_aiohttp):
-    """Test creating an Anthropic provider."""
-    from praisonai.integrations.managed_agents import ManagedAgentIntegration
-    
-    # Mock aiohttp to be available
-    mock_aiohttp.__bool__ = lambda: True
-    
-    managed = ManagedAgentIntegration(
-        provider="anthropic", 
-        api_key="test_key"
-    )
+    # Verify backend is stored
+    assert agent.backend == mock_backend
+
+
+def test_agent_env_key_resolution():
+    """Test API key resolution from environment variables."""
+    from praisonai.integrations.managed_agents import AnthropicManagedAgent
     
-    assert managed.provider == "anthropic"
-    assert managed.api_key == "test_key"
-    assert managed.backend is not None
-    assert managed.is_available
-
-
-def test_unsupported_provider():
-    """Test creating integration with unsupported provider."""
-    with patch('praisonai.integrations.managed_agents.aiohttp'):
-        from praisonai.integrations.managed_agents import ManagedAgentIntegration
-        
-        with pytest.raises(ValueError, match="Unsupported provider: unknown"):
-            ManagedAgentIntegration(provider="unknown", api_key="test_key")
-
-
-def test_session_caching():
-    """Test that session IDs are cached correctly (regression test for #357 bug)."""
-    with patch('praisonai.integrations.managed_agents.aiohttp'):
-        from praisonai.integrations.managed_agents import ManagedAgentIntegration
-        
-        managed = ManagedAgentIntegration(provider="anthropic", api_key="test_key")
-        
-        # Simulate adding session to cache
-        managed._session_cache["test_session"] = "session_id_123"
-        
-        # Verify the correct session ID is cached (not the key)
-        assert managed._session_cache["test_session"] == "session_id_123"
-        assert managed._session_cache["test_session"] != "test_session"
-
-
-def test_api_key_persistence():
-    """Test that API keys from environment are persisted (regression test)."""
-    with patch('praisonai.integrations.managed_agents.aiohttp'), \
-         patch('os.getenv', return_value="env_api_key"):
-        
-        from praisonai.integrations.managed_agents import ManagedAgentIntegration
-        
-        # Create without explicit API key to trigger env lookup
-        managed = ManagedAgentIntegration(provider="anthropic", api_key=None)
-        
-        # Should have stored the env key back to api_key
-        assert managed.api_key == "env_api_key"
\ No newline at end of file
+    # Test ANTHROPIC_API_KEY
+    with patch.dict('os.environ', {'ANTHROPIC_API_KEY': 'anthropic-key'}, clear=True):
+        managed = AnthropicManagedAgent()
+        assert managed.api_key == "anthropic-key"
+    
+    # Test CLAUDE_API_KEY fallback
+    with patch.dict('os.environ', {'CLAUDE_API_KEY': 'claude-key'}, clear=True):
+        managed = AnthropicManagedAgent()
+        assert managed.api_key == "claude-key"
+    
+    # Test explicit key overrides env
+    with patch.dict('os.environ', {'ANTHROPIC_API_KEY': 'env-key'}, clear=True):
+        managed = AnthropicManagedAgent(api_key="explicit-key")
+        assert managed.api_key == "explicit-key"
+
+
+def test_usage_tracking_initialization():
+    """Test that usage tracking counters are properly initialized."""
+    from praisonai.integrations.managed_agents import AnthropicManagedAgent
+    
+    managed = AnthropicManagedAgent(api_key="test-key")
+    
+    assert managed.total_input_tokens == 0
+    assert managed.total_output_tokens == 0
+    
+    # Test that reset_all clears counters
+    managed.total_input_tokens = 100
+    managed.total_output_tokens = 200
+    managed.reset_all()
+    
+    assert managed.total_input_tokens == 0
+    assert managed.total_output_tokens == 0
+
+
+def test_backward_compatible_aliases():
+    """Test backward compatible class aliases."""
+    from praisonai.integrations.managed_agents import ManagedAgentIntegration, ManagedBackendConfig, ManagedAgent, ManagedConfig
+    
+    # Test that aliases exist and point to correct classes
+    assert ManagedAgentIntegration == ManagedAgent
+    assert ManagedBackendConfig == ManagedConfig
+
+
+@patch('praisonai.integrations.managed_agents.logger')
+def test_logging_integration(mock_logger):
+    """Test that managed agents include proper logging."""
+    from praisonai.integrations.managed_agents import AnthropicManagedAgent
+    
+    managed = AnthropicManagedAgent(api_key="test-key")
+    managed.reset_session()
+    managed.reset_all()
+    
+    # Verify logging is available (don't assert specific calls since they may not happen in unit tests)
+    assert mock_logger is not None
\ No newline at end of file