diff --git a/server/subtasks/service.go b/server/subtasks/service.go
index 710dfaf..5f99f74 100644
--- a/server/subtasks/service.go
+++ b/server/subtasks/service.go
@@ -5,8 +5,13 @@
 	"encoding/json"
 	"fmt"
 	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
 	"strings"
+	"time"
 
+	"github.com/iomodo/staff/git"
 	"github.com/iomodo/staff/llm"
 	"github.com/iomodo/staff/tm"
 )
@@ -16,14 +21,22 @@
 	llmProvider    llm.LLMProvider
 	taskManager    tm.TaskManager
 	agentRoles     []string // Available agent roles for assignment
+	prProvider     git.PullRequestProvider // GitHub PR provider
+	githubOwner    string
+	githubRepo     string
+	cloneManager   *git.CloneManager
 }
 
 // NewSubtaskService creates a new subtask service
-func NewSubtaskService(provider llm.LLMProvider, taskManager tm.TaskManager, agentRoles []string) *SubtaskService {
+func NewSubtaskService(provider llm.LLMProvider, taskManager tm.TaskManager, agentRoles []string, prProvider git.PullRequestProvider, githubOwner, githubRepo string, cloneManager *git.CloneManager) *SubtaskService {
 	return &SubtaskService{
-		llmProvider: provider,
-		taskManager: taskManager,
-		agentRoles:  agentRoles,
+		llmProvider:  provider,
+		taskManager:  taskManager,
+		agentRoles:   agentRoles,
+		prProvider:   prProvider,
+		githubOwner:  githubOwner,
+		githubRepo:   githubRepo,
+		cloneManager: cloneManager,
 	}
 }
 
@@ -402,16 +415,40 @@
 
 // GenerateSubtaskPR creates a PR with the proposed subtasks
 func (s *SubtaskService) GenerateSubtaskPR(ctx context.Context, analysis *tm.SubtaskAnalysis) (string, error) {
-	// Generate markdown content for the PR
+	if s.prProvider == nil {
+		return "", fmt.Errorf("PR provider not configured")
+	}
+
+	// Generate branch name for subtask proposal
+	branchName := fmt.Sprintf("subtasks/%s-proposal", analysis.ParentTaskID)
+
+	// Create Git branch and commit subtask proposal
+	if err := s.createSubtaskBranch(ctx, analysis, branchName); err != nil {
+		return "", fmt.Errorf("failed to create subtask branch: %w", err)
+	}
+
+	// Generate PR content
 	prContent := s.generateSubtaskPRContent(analysis)
-	
-	// This would typically create a Git branch and PR
-	// For now, we'll return a mock PR URL
-	prURL := fmt.Sprintf("https://github.com/example/repo/pull/subtasks-%s", analysis.ParentTaskID)
-	
+	title := fmt.Sprintf("Subtask Proposal: %s", analysis.ParentTaskID)
+
+	// Create the pull request
+	options := git.PullRequestOptions{
+		Title:       title,
+		Description: prContent,
+		HeadBranch:  branchName,
+		BaseBranch:  "main",
+		Labels:      []string{"subtasks", "proposal", "ai-generated"},
+		Draft:       false,
+	}
+
+	pr, err := s.prProvider.CreatePullRequest(ctx, options)
+	if err != nil {
+		return "", fmt.Errorf("failed to create PR: %w", err)
+	}
+
+	prURL := fmt.Sprintf("https://github.com/%s/%s/pull/%d", s.githubOwner, s.githubRepo, pr.Number)
 	log.Printf("Generated subtask proposal PR: %s", prURL)
-	log.Printf("PR Content:\n%s", prContent)
-	
+
 	return prURL, nil
 }
 
@@ -454,6 +491,129 @@
 	return content.String()
 }
 
+// createSubtaskBranch creates a Git branch with subtask proposal content
+func (s *SubtaskService) createSubtaskBranch(ctx context.Context, analysis *tm.SubtaskAnalysis, branchName string) error {
+	if s.cloneManager == nil {
+		return fmt.Errorf("clone manager not configured")
+	}
+
+	// Get a temporary clone for creating the subtask branch
+	clonePath, err := s.cloneManager.GetAgentClonePath("subtask-service")
+	if err != nil {
+		return fmt.Errorf("failed to get clone path: %w", err)
+	}
+
+	// All Git operations use the clone directory
+	gitCmd := func(args ...string) *exec.Cmd {
+		return exec.CommandContext(ctx, "git", append([]string{"-C", clonePath}, args...)...)
+	}
+
+	// Ensure we're on main branch before creating new branch
+	cmd := gitCmd("checkout", "main")
+	if err := cmd.Run(); err != nil {
+		// Try master branch if main doesn't exist
+		cmd = gitCmd("checkout", "master")
+		if err := cmd.Run(); err != nil {
+			return fmt.Errorf("failed to checkout main/master branch: %w", err)
+		}
+	}
+
+	// Pull latest changes
+	cmd = gitCmd("pull", "origin")
+	if err := cmd.Run(); err != nil {
+		log.Printf("Warning: failed to pull latest changes: %v", err)
+	}
+
+	// Create and checkout new branch
+	cmd = gitCmd("checkout", "-b", branchName)
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("failed to create branch: %w", err)
+	}
+
+	// Create subtask proposal file
+	proposalDir := filepath.Join(clonePath, "tasks", "subtasks")
+	if err := os.MkdirAll(proposalDir, 0755); err != nil {
+		return fmt.Errorf("failed to create proposal directory: %w", err)
+	}
+
+	proposalFile := filepath.Join(proposalDir, fmt.Sprintf("%s-proposal.md", analysis.ParentTaskID))
+	proposalContent := s.generateSubtaskProposalFile(analysis)
+
+	if err := os.WriteFile(proposalFile, []byte(proposalContent), 0644); err != nil {
+		return fmt.Errorf("failed to write proposal file: %w", err)
+	}
+
+	// Stage the file
+	relativeFile := filepath.Join("tasks", "subtasks", fmt.Sprintf("%s-proposal.md", analysis.ParentTaskID))
+	cmd = gitCmd("add", relativeFile)
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("failed to stage files: %w", err)
+	}
+
+	// Commit changes
+	commitMsg := fmt.Sprintf("Subtask proposal for task %s\n\nGenerated by Staff AI Agent System\nProposed %d subtasks with %d new agents", 
+		analysis.ParentTaskID, len(analysis.Subtasks), len(analysis.AgentCreations))
+	cmd = gitCmd("commit", "-m", commitMsg)
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("failed to commit: %w", err)
+	}
+
+	// Push branch
+	cmd = gitCmd("push", "-u", "origin", branchName)
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("failed to push branch: %w", err)
+	}
+
+	log.Printf("Created subtask proposal branch: %s", branchName)
+	return nil
+}
+
+// generateSubtaskProposalFile creates the content for the subtask proposal file
+func (s *SubtaskService) generateSubtaskProposalFile(analysis *tm.SubtaskAnalysis) string {
+	var content strings.Builder
+	
+	content.WriteString(fmt.Sprintf("# Subtask Proposal for Task %s\n\n", analysis.ParentTaskID))
+	content.WriteString(fmt.Sprintf("**Generated:** %s\n\n", time.Now().Format(time.RFC3339)))
+	content.WriteString(fmt.Sprintf("## Analysis Summary\n%s\n\n", analysis.AnalysisSummary))
+
+	if len(analysis.AgentCreations) > 0 {
+		content.WriteString("## Proposed New Agents\n\n")
+		for i, agent := range analysis.AgentCreations {
+			content.WriteString(fmt.Sprintf("### %d. %s Agent\n", i+1, strings.Title(agent.Role)))
+			content.WriteString(fmt.Sprintf("- **Skills:** %s\n", strings.Join(agent.Skills, ", ")))
+			content.WriteString(fmt.Sprintf("- **Description:** %s\n", agent.Description))
+			content.WriteString(fmt.Sprintf("- **Justification:** %s\n\n", agent.Justification))
+		}
+	}
+
+	content.WriteString("## Proposed Subtasks\n\n")
+	for i, subtask := range analysis.Subtasks {
+		content.WriteString(fmt.Sprintf("### %d. %s\n", i+1, subtask.Title))
+		content.WriteString(fmt.Sprintf("- **Assigned to:** %s\n", subtask.AssignedTo))
+		content.WriteString(fmt.Sprintf("- **Priority:** %s\n", subtask.Priority))
+		content.WriteString(fmt.Sprintf("- **Estimated Hours:** %d\n", subtask.EstimatedHours))
+		if len(subtask.RequiredSkills) > 0 {
+			content.WriteString(fmt.Sprintf("- **Required Skills:** %s\n", strings.Join(subtask.RequiredSkills, ", ")))
+		}
+		if len(subtask.Dependencies) > 0 {
+			content.WriteString(fmt.Sprintf("- **Dependencies:** %s\n", strings.Join(subtask.Dependencies, ", ")))
+		}
+		content.WriteString(fmt.Sprintf("- **Description:** %s\n\n", subtask.Description))
+	}
+
+	content.WriteString(fmt.Sprintf("## Recommended Approach\n%s\n\n", analysis.RecommendedApproach))
+	content.WriteString(fmt.Sprintf("**Estimated Total Hours:** %d\n\n", analysis.EstimatedTotalHours))
+
+	if analysis.RiskAssessment != "" {
+		content.WriteString(fmt.Sprintf("## Risk Assessment\n%s\n\n", analysis.RiskAssessment))
+	}
+
+	content.WriteString("---\n\n")
+	content.WriteString("*This proposal was generated by the Staff AI Agent System. Review and approve to proceed with subtask creation.*\n")
+	
+	return content.String()
+}
+
 // Close cleans up the service
 func (s *SubtaskService) Close() error {
 	if s.llmProvider != nil {