diff --git a/loop/agent.go b/loop/agent.go
index c407420..497f048 100644
--- a/loop/agent.go
+++ b/loop/agent.go
@@ -822,7 +822,10 @@
 			// hence the mutex.
 			a.cancelTurn = cancel
 			a.cancelTurnMu.Unlock()
-			a.processTurn(ctxInner) // Renamed from InnerLoop to better reflect its purpose
+			err := a.processTurn(ctxInner) // Renamed from InnerLoop to better reflect its purpose
+			if err != nil {
+				slog.ErrorContext(ctxOuter, "Error in processing turn", "error", err)
+			}
 			cancel(nil)
 		}
 	}
@@ -876,14 +879,21 @@
 }
 
 // processTurn handles a single conversation turn with the user
-func (a *Agent) processTurn(ctx context.Context) {
+func (a *Agent) processTurn(ctx context.Context) error {
 	// Reset the start of turn time
 	a.startOfTurn = time.Now()
 
 	// Process initial user message
 	initialResp, err := a.processUserMessage(ctx)
 	if err != nil {
-		return
+		return err
+	}
+
+	// Handle edge case where both initialResp and err are nil
+	if initialResp == nil {
+		err := fmt.Errorf("unexpected nil response from processUserMessage with no error")
+		a.pushToOutbox(ctx, errorMessage(err))
+		return err
 	}
 
 	// We do this as we go, but let's also do it at the end of the turn
@@ -899,7 +909,7 @@
 	for {
 		// Check if we are over budget
 		if err := a.overBudget(ctx); err != nil {
-			return
+			return err
 		}
 
 		// If the model is not requesting to use a tool, we're done
@@ -910,12 +920,14 @@
 		// Handle tool execution
 		continueConversation, toolResp := a.handleToolExecution(ctx, resp)
 		if !continueConversation {
-			return
+			return nil
 		}
 
 		// Set the response for the next iteration
 		resp = toolResp
 	}
+
+	return nil
 }
 
 // processUserMessage waits for user messages and sends them to the model
diff --git a/loop/agent_test.go b/loop/agent_test.go
index b3b4ae1..61b057c 100644
--- a/loop/agent_test.go
+++ b/loop/agent_test.go
@@ -2,6 +2,7 @@
 
 import (
 	"context"
+	"fmt"
 	"net/http"
 	"os"
 	"strings"
@@ -204,3 +205,174 @@
 		t.Errorf("Expected 'think' tool remaining, got %s", tools[0])
 	}
 }
+
+// TestAgentProcessTurnWithNilResponse tests the scenario where Agent.processTurn receives
+// a nil value for initialResp from processUserMessage.
+func TestAgentProcessTurnWithNilResponse(t *testing.T) {
+	// Create a mock conversation that will return nil and error
+	mockConvo := &MockConvoInterface{
+		sendMessageFunc: func(message ant.Message) (*ant.MessageResponse, error) {
+			return nil, fmt.Errorf("test error: simulating nil response")
+		},
+	}
+
+	// Create a minimal Agent instance for testing
+	agent := &Agent{
+		convo:                mockConvo,
+		inbox:                make(chan string, 10),
+		outbox:               make(chan AgentMessage, 10),
+		outstandingLLMCalls:  make(map[string]struct{}),
+		outstandingToolCalls: make(map[string]string),
+	}
+
+	// Create a test context
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+	defer cancel()
+
+	// Push a test message to the inbox so that processUserMessage will try to process it
+	agent.inbox <- "Test message"
+
+	// Call processTurn - it should exit early without panic when initialResp is nil
+	agent.processTurn(ctx)
+
+	// Verify the error message was added to outbox
+	select {
+	case msg := <-agent.outbox:
+		if msg.Type != ErrorMessageType {
+			t.Errorf("Expected error message, got message type: %s", msg.Type)
+		}
+		if !strings.Contains(msg.Content, "simulating nil response") {
+			t.Errorf("Expected error message to contain 'simulating nil response', got: %s", msg.Content)
+		}
+	case <-time.After(time.Second):
+		t.Error("Timed out waiting for error message in outbox")
+	}
+
+	// No more messages should be in the outbox since processTurn should exit early
+	select {
+	case msg := <-agent.outbox:
+		t.Errorf("Expected no more messages in outbox, but got: %+v", msg)
+	case <-time.After(100 * time.Millisecond):
+		// This is the expected outcome - no more messages
+	}
+}
+
+// MockConvoInterface implements the ConvoInterface for testing
+type MockConvoInterface struct {
+	sendMessageFunc              func(message ant.Message) (*ant.MessageResponse, error)
+	sendUserTextMessageFunc      func(s string, otherContents ...ant.Content) (*ant.MessageResponse, error)
+	toolResultContentsFunc       func(ctx context.Context, resp *ant.MessageResponse) ([]ant.Content, error)
+	toolResultCancelContentsFunc func(resp *ant.MessageResponse) ([]ant.Content, error)
+	cancelToolUseFunc            func(toolUseID string, cause error) error
+	cumulativeUsageFunc          func() ant.CumulativeUsage
+	resetBudgetFunc              func(ant.Budget)
+	overBudgetFunc               func() error
+}
+
+func (m *MockConvoInterface) SendMessage(message ant.Message) (*ant.MessageResponse, error) {
+	if m.sendMessageFunc != nil {
+		return m.sendMessageFunc(message)
+	}
+	return nil, nil
+}
+
+func (m *MockConvoInterface) SendUserTextMessage(s string, otherContents ...ant.Content) (*ant.MessageResponse, error) {
+	if m.sendUserTextMessageFunc != nil {
+		return m.sendUserTextMessageFunc(s, otherContents...)
+	}
+	return nil, nil
+}
+
+func (m *MockConvoInterface) ToolResultContents(ctx context.Context, resp *ant.MessageResponse) ([]ant.Content, error) {
+	if m.toolResultContentsFunc != nil {
+		return m.toolResultContentsFunc(ctx, resp)
+	}
+	return nil, nil
+}
+
+func (m *MockConvoInterface) ToolResultCancelContents(resp *ant.MessageResponse) ([]ant.Content, error) {
+	if m.toolResultCancelContentsFunc != nil {
+		return m.toolResultCancelContentsFunc(resp)
+	}
+	return nil, nil
+}
+
+func (m *MockConvoInterface) CancelToolUse(toolUseID string, cause error) error {
+	if m.cancelToolUseFunc != nil {
+		return m.cancelToolUseFunc(toolUseID, cause)
+	}
+	return nil
+}
+
+func (m *MockConvoInterface) CumulativeUsage() ant.CumulativeUsage {
+	if m.cumulativeUsageFunc != nil {
+		return m.cumulativeUsageFunc()
+	}
+	return ant.CumulativeUsage{}
+}
+
+func (m *MockConvoInterface) ResetBudget(budget ant.Budget) {
+	if m.resetBudgetFunc != nil {
+		m.resetBudgetFunc(budget)
+	}
+}
+
+func (m *MockConvoInterface) OverBudget() error {
+	if m.overBudgetFunc != nil {
+		return m.overBudgetFunc()
+	}
+	return nil
+}
+
+// TestAgentProcessTurnWithNilResponseNilError tests the scenario where Agent.processTurn receives
+// a nil value for initialResp and nil error from processUserMessage.
+// This test verifies that the implementation properly handles this edge case.
+func TestAgentProcessTurnWithNilResponseNilError(t *testing.T) {
+	// Create a mock conversation that will return nil response and nil error
+	mockConvo := &MockConvoInterface{
+		sendMessageFunc: func(message ant.Message) (*ant.MessageResponse, error) {
+			return nil, nil // This is unusual but now handled gracefully
+		},
+	}
+
+	// Create a minimal Agent instance for testing
+	agent := &Agent{
+		convo:                mockConvo,
+		inbox:                make(chan string, 10),
+		outbox:               make(chan AgentMessage, 10),
+		outstandingLLMCalls:  make(map[string]struct{}),
+		outstandingToolCalls: make(map[string]string),
+	}
+
+	// Create a test context
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+	defer cancel()
+
+	// Push a test message to the inbox so that processUserMessage will try to process it
+	agent.inbox <- "Test message"
+
+	// Call processTurn - it should handle nil initialResp with a descriptive error
+	err := agent.processTurn(ctx)
+
+	// Verify we get the expected error
+	if err == nil {
+		t.Error("Expected processTurn to return an error for nil initialResp, but got nil")
+	} else if !strings.Contains(err.Error(), "unexpected nil response") {
+		t.Errorf("Expected error about nil response, got: %v", err)
+	} else {
+		t.Logf("As expected, processTurn returned error: %v", err)
+	}
+
+	// Verify an error message was sent to the outbox
+	select {
+	case msg := <-agent.outbox:
+		if msg.Type != ErrorMessageType {
+			t.Errorf("Expected error message type, got: %s", msg.Type)
+		}
+		if !strings.Contains(msg.Content, "unexpected nil response") {
+			t.Errorf("Expected error about nil response, got: %s", msg.Content)
+		}
+	case <-time.After(time.Second):
+		t.Error("Timed out waiting for error message in outbox")
+	}
+}