diff --git a/tests/agents/test_tatlock_agent.py b/tests/agents/test_tatlock_agent.py
new file mode 100644
index 0000000..fcd427b
--- /dev/null
+++ b/tests/agents/test_tatlock_agent.py
@@ -0,0 +1,355 @@
+"""
+Tests for Tatlock agent conversation history and tool call logging.
+
+These tests verify:
+1. Conversation history is properly passed to PydanticAI (Tatlock remembers context)
+2. Tool calls are logged to reasoning output (users see what tools are doing)
+"""
+
+import json
+import pytest
+from unittest.mock import patch, AsyncMock
+from httpx import AsyncClient
+
+
+@pytest.mark.integration
+@pytest.mark.asyncio
+async def test_tatlock_conversation_history_memory(async_client: AsyncClient):
+    """
+    Test that Tatlock remembers previous turns of the conversation.
+
+    This verifies the fix where Tatlock was only using the last user message
+    instead of the full conversation history.
+    """
+    # First turn: User introduces themselves
+    request_data_1 = {
+        "model": "Tatlock",
+        "messages": [
+            {"role": "user", "content": "My name is Alice and I love Python programming."}
+        ],
+        "stream": False
+    }
+
+    response_1 = await async_client.post(
+        "/v1/chat/completions",
+        json=request_data_1,
+        timeout=30.0
+    )
+
+    assert response_1.status_code == 200
+    data_1 = response_1.json()
+    first_response = data_1["choices"][0]["message"]["content"]
+
+    # Second turn: Ask about previous information
+    # Tatlock should remember the user's name and interest
+    request_data_2 = {
+        "model": "Tatlock",
+        "messages": [
+            {"role": "user", "content": "My name is Alice and I love Python programming."},
+            {"role": "assistant", "content": first_response},
+            {"role": "user", "content": "What did I say my name was? And what programming language did I mention?"}
+        ],
+        "stream": False
+    }
+
+    response_2 = await async_client.post(
+        "/v1/chat/completions",
+        json=request_data_2,
+        timeout=30.0
+    )
+
+    assert response_2.status_code == 200
+    data_2 = response_2.json()
+    second_response = data_2["choices"][0]["message"]["content"].lower()
+
+    # Verify Tatlock remembers the name and programming language
+    assert "alice" in second_response, f"Tatlock should remember the name 'Alice'. Response: {second_response}"
+    assert "python" in second_response, f"Tatlock should remember 'Python'. Response: {second_response}"
+
+
+@pytest.mark.integration
+@pytest.mark.asyncio
+async def test_tatlock_multi_turn_context(async_client: AsyncClient):
+    """
+    Test that Tatlock maintains context over multiple turns.
+
+    Verifies conversation history is properly accumulated.
+    """
+    # Build a multi-turn conversation
+    conversation = []
+
+    # Turn 1: Set up a topic
+    conversation.append({"role": "user", "content": "Let's talk about the number 42."})
+
+    request_1 = {
+        "model": "Tatlock",
+        "messages": conversation.copy(),
+        "stream": False
+    }
+
+    response_1 = await async_client.post(
+        "/v1/chat/completions",
+        json=request_1,
+        timeout=30.0
+    )
+
+    assert response_1.status_code == 200
+    data_1 = response_1.json()
+    conversation.append({
+        "role": "assistant",
+        "content": data_1["choices"][0]["message"]["content"]
+    })
+
+    # Turn 2: Reference "it" (should refer to 42)
+    conversation.append({"role": "user", "content": "What number did I just mention?"})
+
+    request_2 = {
+        "model": "Tatlock",
+        "messages": conversation.copy(),
+        "stream": False
+    }
+
+    response_2 = await async_client.post(
+        "/v1/chat/completions",
+        json=request_2,
+        timeout=30.0
+    )
+
+    assert response_2.status_code == 200
+    data_2 = response_2.json()
+    final_response = data_2["choices"][0]["message"]["content"]
+
+    # Should reference 42
+    assert "42" in final_response, f"Tatlock should remember the number 42 from context. Response: {final_response}"
+
+
+@pytest.mark.integration
+@pytest.mark.asyncio
+async def test_tatlock_tool_call_logging_search(async_client: AsyncClient):
+    """
+    Test that web search tool calls are logged to reasoning output.
+
+    This verifies that when Tatlock uses the search tool, the query
+    is visible in the chat response (in <think> tags).
+    """
+    request_data = {
+        "model": "Tatlock",
+        "messages": [
+            {"role": "user", "content": "Search for current information about Python 3.13 release date"}
+        ],
+        "stream": False
+    }
+
+    response = await async_client.post(
+        "/v1/chat/completions",
+        json=request_data,
+        timeout=60.0
+    )
+
+    assert response.status_code == 200
+    data = response.json()
+    full_response = data["choices"][0]["message"]["content"]
+
+    # Tool calls should appear in <think> tags
+    assert "<think>" in full_response, "Should have reasoning/tool output in <think> tags"
+
+    # Should contain search indicator emoji (if search was used)
+    # OR the LLM might answer without searching if it has the info
+    # So we just verify the mechanism works by checking for think tags
+    print(f"\nFull response with tool logging:\n{full_response}")
+
+    # If search was used, should show the 🔍 emoji
+    if "🔍" in full_response:
+        assert "search" in full_response.lower() or "python" in full_response.lower(), \
+            "Search query should be visible in the response"
+
+
+@pytest.mark.integration
+@pytest.mark.asyncio
+async def test_tatlock_tool_call_logging_calculator(async_client: AsyncClient):
+    """
+    Test that calculator tool calls are logged to reasoning output.
+
+    Verifies that mathematical calculations show what expression was evaluated.
+    """
+    request_data = {
+        "model": "Tatlock",
+        "messages": [
+            {"role": "user", "content": "What is the square root of 144 plus 25?"}
+        ],
+        "stream": False
+    }
+
+    response = await async_client.post(
+        "/v1/chat/completions",
+        json=request_data,
+        timeout=30.0
+    )
+
+    assert response.status_code == 200
+    data = response.json()
+    full_response = data["choices"][0]["message"]["content"]
+
+    # Should have calculator emoji in the response
+    assert "🧮" in full_response, \
+        f"Response should show calculator was used. Got: {full_response}"
+
+    # Should show the calculation expression
+    assert "sqrt(144)" in full_response or "144" in full_response, \
+        f"Should show what was calculated. Got: {full_response}"
+
+    # Should have the correct answer (37)
+    assert "37" in full_response, \
+        f"Should contain the answer 37. Got: {full_response}"
+
+    print(f"\nCalculator response: {full_response}")
+
+
+@pytest.mark.integration
+@pytest.mark.asyncio
+async def test_tatlock_tool_call_logging_datetime(async_client: AsyncClient):
+    """
+    Test that date/time tool calls are logged to reasoning output.
+    """
+    request_data = {
+        "model": "Tatlock",
+        "messages": [
+            {"role": "user", "content": "What was the date exactly 2 weeks ago?"}
+        ],
+        "stream": False
+    }
+
+    response = await async_client.post(
+        "/v1/chat/completions",
+        json=request_data,
+        timeout=30.0
+    )
+
+    assert response.status_code == 200
+    data = response.json()
+    full_response = data["choices"][0]["message"]["content"]
+
+    # Should have reasoning in <think> tags
+    assert "<think>" in full_response, "Should have reasoning output in <think> tags"
+
+    # Check if date/time tool was used (LLM might calculate it itself sometimes)
+    used_date_tool = "🕐" in full_response
+
+    # Should mention the calculation or the timeframe
+    assert "2 weeks ago" in full_response.lower() or "weeks" in full_response.lower(), \
+        f"Should reference the requested timeframe. Got: {full_response}"
+
+    # Should provide a specific date (either YYYY-MM-DD format or natural language like "November 23")
+    import re
+    has_iso_date = bool(re.search(r'\d{4}-\d{2}-\d{2}', full_response))
+    has_month_mention = any(month in full_response.lower() for month in
+                            ['january', 'february', 'march', 'april', 'may', 'june',
+                             'july', 'august', 'september', 'october', 'november', 'december'])
+    has_date_number = bool(re.search(r'\b\d{1,2}(st|nd|rd|th)?\b', full_response.lower()))
+
+    assert has_iso_date or has_month_mention or has_date_number, \
+        f"Should contain a specific date. Got: {full_response}"
+
+    print(f"\nDate/time response (tool used: {used_date_tool}): {full_response}")
+
+
+@pytest.mark.integration
+@pytest.mark.asyncio
+async def test_tatlock_no_tool_calls_no_logging(async_client: AsyncClient):
+    """
+    Test that when no tools are used, no tool logging appears.
+
+    Verifies the tool logging only appears when tools are actually called.
+    """
+    request_data = {
+        "model": "Tatlock",
+        "messages": [
+            {"role": "user", "content": "Just say hello to me."}
+        ],
+        "stream": False
+    }
+
+    response = await async_client.post(
+        "/v1/chat/completions",
+        json=request_data,
+        timeout=30.0
+    )
+
+    assert response.status_code == 200
+    data = response.json()
+    full_response = data["choices"][0]["message"]["content"]
+
+    # Should have basic reasoning in <think> tags
+    assert "<think>" in full_response, "Should have reasoning output in <think> tags"
+
+    # Should NOT have tool emojis (for a simple greeting)
+    has_tool_emoji = any(emoji in full_response for emoji in ["🔍", "🧮", "🕐"])
+
+    print(f"\nResponse without tools: {full_response}")
+    print(f"Has tool emojis: {has_tool_emoji}")
+
+    # Just verify we got a greeting response
+    assert len(full_response) > 0, "Should have a response"
+
+
+@pytest.mark.integration
+@pytest.mark.asyncio
+async def test_tatlock_conversation_history_with_tools(async_client: AsyncClient):
+    """
+    Test that conversation history works correctly when tools are used.
+
+    Combines both features: history + tool logging.
+    """
+    conversation = []
+
+    # Turn 1: Do a calculation
+    conversation.append({"role": "user", "content": "Calculate 15 times 7 for me."})
+
+    request_1 = {
+        "model": "Tatlock",
+        "messages": conversation.copy(),
+        "stream": False
+    }
+
+    response_1 = await async_client.post(
+        "/v1/chat/completions",
+        json=request_1,
+        timeout=30.0
+    )
+
+    assert response_1.status_code == 200
+    data_1 = response_1.json()
+    first_response = data_1["choices"][0]["message"]["content"]
+
+    # Should contain the answer (105)
+    assert "105" in first_response, f"Should calculate 15*7=105. Got: {first_response}"
+
+    conversation.append({"role": "assistant", "content": first_response})
+
+    # Turn 2: Ask about previous calculation
+    conversation.append({"role": "user", "content": "What calculation did I just ask you to do?"})
+
+    request_2 = {
+        "model": "Tatlock",
+        "messages": conversation.copy(),
+        "stream": False
+    }
+
+    response_2 = await async_client.post(
+        "/v1/chat/completions",
+        json=request_2,
+        timeout=30.0
+    )
+
+    assert response_2.status_code == 200
+    data_2 = response_2.json()
+    second_response = data_2["choices"][0]["message"]["content"].lower()
+
+    # Should remember the calculation (either as digits or words)
+    has_calculation = (
+        ("15" in second_response and "7" in second_response) or  # As digits
+        ("fifteen" in second_response.lower() and "seven" in second_response.lower()) or  # As words
+        "105" in second_response  # As answer
+    )
+    assert has_calculation, \
+        f"Tatlock should remember the previous calculation (15 times 7 = 105). Got: {second_response}"