diff --git a/server/agent/simple_manager.go b/server/agent/simple_manager.go
new file mode 100644
index 0000000..27d522d
--- /dev/null
+++ b/server/agent/simple_manager.go
@@ -0,0 +1,565 @@
+package agent
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/iomodo/staff/assignment"
+	"github.com/iomodo/staff/config"
+	"github.com/iomodo/staff/git"
+	"github.com/iomodo/staff/llm"
+	"github.com/iomodo/staff/tm"
+)
+
+// SimpleAgent represents a simplified AI agent for MVP
+type SimpleAgent struct {
+	Name         string
+	Role         string
+	Model        string
+	SystemPrompt string
+	Provider     llm.LLMProvider
+	MaxTokens    *int
+	Temperature  *float64
+}
+
+// SimpleAgentManager manages multiple AI agents with basic Git operations
+type SimpleAgentManager struct {
+	config       *config.Config
+	agents       map[string]*SimpleAgent
+	taskManager  tm.TaskManager
+	autoAssigner *assignment.AutoAssigner
+	prProvider   git.PullRequestProvider
+	cloneManager *git.CloneManager
+	isRunning    map[string]bool
+	stopChannels map[string]chan struct{}
+}
+
+// NewSimpleAgentManager creates a simplified agent manager
+func NewSimpleAgentManager(cfg *config.Config, taskManager tm.TaskManager) (*SimpleAgentManager, error) {
+	// Create auto-assigner
+	autoAssigner := assignment.NewAutoAssigner(cfg.Agents)
+
+	// Create GitHub PR provider
+	githubConfig := git.GitHubConfig{
+		Token: cfg.GitHub.Token,
+	}
+	prProvider := git.NewGitHubPullRequestProvider(cfg.GitHub.Owner, cfg.GitHub.Repo, githubConfig)
+
+	// Create clone manager for per-agent Git repositories
+	repoURL := fmt.Sprintf("https://github.com/%s/%s.git", cfg.GitHub.Owner, cfg.GitHub.Repo)
+	workspacePath := filepath.Join(".", "workspace")
+	cloneManager := git.NewCloneManager(repoURL, workspacePath)
+
+	manager := &SimpleAgentManager{
+		config:       cfg,
+		agents:       make(map[string]*SimpleAgent),
+		taskManager:  taskManager,
+		autoAssigner: autoAssigner,
+		prProvider:   prProvider,
+		cloneManager: cloneManager,
+		isRunning:    make(map[string]bool),
+		stopChannels: make(map[string]chan struct{}),
+	}
+
+	// Initialize agents
+	if err := manager.initializeAgents(); err != nil {
+		return nil, fmt.Errorf("failed to initialize agents: %w", err)
+	}
+
+	return manager, nil
+}
+
+// initializeAgents creates agent instances from configuration
+func (am *SimpleAgentManager) initializeAgents() error {
+	for _, agentConfig := range am.config.Agents {
+		agent, err := am.createAgent(agentConfig)
+		if err != nil {
+			return fmt.Errorf("failed to create agent %s: %w", agentConfig.Name, err)
+		}
+		am.agents[agentConfig.Name] = agent
+	}
+	return nil
+}
+
+// createAgent creates a single agent instance
+func (am *SimpleAgentManager) createAgent(agentConfig config.AgentConfig) (*SimpleAgent, error) {
+	// Load system prompt
+	systemPrompt, err := am.loadSystemPrompt(agentConfig.SystemPromptFile)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load system prompt: %w", err)
+	}
+
+	// Create LLM provider
+	llmConfig := llm.Config{
+		Provider: llm.ProviderOpenAI,
+		APIKey:   am.config.OpenAI.APIKey,
+		BaseURL:  am.config.OpenAI.BaseURL,
+		Timeout:  am.config.OpenAI.Timeout,
+	}
+	
+	provider, err := llm.CreateProvider(llmConfig)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create LLM provider: %w", err)
+	}
+
+	agent := &SimpleAgent{
+		Name:         agentConfig.Name,
+		Role:         agentConfig.Role,
+		Model:        agentConfig.Model,
+		SystemPrompt: systemPrompt,
+		Provider:     provider,
+		MaxTokens:    agentConfig.MaxTokens,
+		Temperature:  agentConfig.Temperature,
+	}
+
+	return agent, nil
+}
+
+// loadSystemPrompt loads the system prompt from file
+func (am *SimpleAgentManager) loadSystemPrompt(filePath string) (string, error) {
+	content, err := os.ReadFile(filePath)
+	if err != nil {
+		return "", fmt.Errorf("failed to read system prompt file %s: %w", filePath, err)
+	}
+	return string(content), nil
+}
+
+// StartAgent starts an agent to process tasks in a loop
+func (am *SimpleAgentManager) StartAgent(agentName string, loopInterval time.Duration) error {
+	agent, exists := am.agents[agentName]
+	if !exists {
+		return fmt.Errorf("agent %s not found", agentName)
+	}
+
+	if am.isRunning[agentName] {
+		return fmt.Errorf("agent %s is already running", agentName)
+	}
+
+	stopChan := make(chan struct{})
+	am.stopChannels[agentName] = stopChan
+	am.isRunning[agentName] = true
+
+	go am.runAgentLoop(agent, loopInterval, stopChan)
+	
+	log.Printf("Started agent %s (%s) with %s model", agentName, agent.Role, agent.Model)
+	return nil
+}
+
+// StopAgent stops a running agent
+func (am *SimpleAgentManager) StopAgent(agentName string) error {
+	if !am.isRunning[agentName] {
+		return fmt.Errorf("agent %s is not running", agentName)
+	}
+
+	close(am.stopChannels[agentName])
+	delete(am.stopChannels, agentName)
+	am.isRunning[agentName] = false
+
+	log.Printf("Stopped agent %s", agentName)
+	return nil
+}
+
+// runAgentLoop runs the main processing loop for an agent
+func (am *SimpleAgentManager) runAgentLoop(agent *SimpleAgent, interval time.Duration, stopChan <-chan struct{}) {
+	ticker := time.NewTicker(interval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-stopChan:
+			log.Printf("Agent %s stopping", agent.Name)
+			return
+		case <-ticker.C:
+			if err := am.processAgentTasks(agent); err != nil {
+				log.Printf("Error processing tasks for agent %s: %v", agent.Name, err)
+			}
+		}
+	}
+}
+
+// processAgentTasks processes all assigned tasks for an agent
+func (am *SimpleAgentManager) processAgentTasks(agent *SimpleAgent) error {
+	// Get tasks assigned to this agent
+	tasks, err := am.taskManager.GetTasksByAssignee(agent.Name)
+	if err != nil {
+		return fmt.Errorf("failed to get tasks for agent %s: %w", agent.Name, err)
+	}
+
+	for _, task := range tasks {
+		if task.Status == tm.StatusPending || task.Status == tm.StatusInProgress {
+			if err := am.processTask(agent, task); err != nil {
+				log.Printf("Error processing task %s: %v", task.ID, err)
+				// Mark task as failed
+				task.Status = tm.StatusFailed
+				if err := am.taskManager.UpdateTask(task); err != nil {
+					log.Printf("Error updating failed task %s: %v", task.ID, err)
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
+// processTask processes a single task with an agent
+func (am *SimpleAgentManager) processTask(agent *SimpleAgent, task *tm.Task) error {
+	ctx := context.Background()
+
+	log.Printf("Agent %s processing task %s: %s", agent.Name, task.ID, task.Title)
+
+	// Mark task as in progress
+	task.Status = tm.StatusInProgress
+	if err := am.taskManager.UpdateTask(task); err != nil {
+		return fmt.Errorf("failed to update task status: %w", err)
+	}
+
+	// Generate solution using LLM
+	solution, err := am.generateSolution(ctx, agent, task)
+	if err != nil {
+		return fmt.Errorf("failed to generate solution: %w", err)
+	}
+
+	// Create Git branch and commit solution
+	branchName := am.generateBranchName(task)
+	if err := am.createAndCommitSolution(branchName, task, solution, agent); err != nil {
+		return fmt.Errorf("failed to commit solution: %w", err)
+	}
+
+	// Create pull request
+	prURL, err := am.createPullRequest(ctx, task, solution, agent, branchName)
+	if err != nil {
+		return fmt.Errorf("failed to create pull request: %w", err)
+	}
+
+	// Update task as completed
+	task.Status = tm.StatusCompleted
+	task.Solution = solution
+	task.PullRequestURL = prURL
+	task.CompletedAt = &time.Time{}
+	*task.CompletedAt = time.Now()
+
+	if err := am.taskManager.UpdateTask(task); err != nil {
+		return fmt.Errorf("failed to update completed task: %w", err)
+	}
+
+	log.Printf("Task %s completed by agent %s. PR: %s", task.ID, agent.Name, prURL)
+	return nil
+}
+
+// generateSolution uses the agent's LLM to generate a solution
+func (am *SimpleAgentManager) generateSolution(ctx context.Context, agent *SimpleAgent, task *tm.Task) (string, error) {
+	prompt := am.buildTaskPrompt(task)
+
+	req := llm.ChatCompletionRequest{
+		Model: agent.Model,
+		Messages: []llm.Message{
+			{
+				Role:    llm.RoleSystem,
+				Content: agent.SystemPrompt,
+			},
+			{
+				Role:    llm.RoleUser,
+				Content: prompt,
+			},
+		},
+		MaxTokens:   agent.MaxTokens,
+		Temperature: agent.Temperature,
+	}
+
+	resp, err := agent.Provider.ChatCompletion(ctx, req)
+	if err != nil {
+		return "", fmt.Errorf("LLM request failed: %w", err)
+	}
+
+	if len(resp.Choices) == 0 {
+		return "", fmt.Errorf("no response from LLM")
+	}
+
+	return resp.Choices[0].Message.Content, nil
+}
+
+// buildTaskPrompt creates a detailed prompt for the LLM
+func (am *SimpleAgentManager) buildTaskPrompt(task *tm.Task) string {
+	return fmt.Sprintf(`Task: %s
+
+Priority: %s
+Description: %s
+
+Please provide a complete solution for this task. Include:
+1. Detailed implementation plan
+2. Code changes needed (if applicable)
+3. Files to be created or modified
+4. Testing considerations
+5. Any dependencies or prerequisites
+
+Your response should be comprehensive and actionable.`,
+		task.Title,
+		task.Priority,
+		task.Description)
+}
+
+// generateBranchName creates a Git branch name for the task
+func (am *SimpleAgentManager) generateBranchName(task *tm.Task) string {
+	// Clean title for use in branch name
+	cleanTitle := strings.ToLower(task.Title)
+	cleanTitle = strings.ReplaceAll(cleanTitle, " ", "-")
+	cleanTitle = strings.ReplaceAll(cleanTitle, "/", "-")
+	// Remove special characters
+	var result strings.Builder
+	for _, r := range cleanTitle {
+		if (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') || r == '-' {
+			result.WriteRune(r)
+		}
+	}
+	cleanTitle = result.String()
+	
+	// Limit length
+	if len(cleanTitle) > 40 {
+		cleanTitle = cleanTitle[:40]
+	}
+	
+	return fmt.Sprintf("%s%s-%s", am.config.Git.BranchPrefix, task.ID, cleanTitle)
+}
+
+// createAndCommitSolution creates a Git branch and commits the solution using per-agent clones
+// Each agent works in its own Git clone, eliminating concurrency issues
+func (am *SimpleAgentManager) createAndCommitSolution(branchName string, task *tm.Task, solution string, agent *SimpleAgent) error {
+	ctx := context.Background()
+	
+	// Get agent's dedicated Git clone
+	clonePath, err := am.cloneManager.GetAgentClonePath(agent.Name)
+	if err != nil {
+		return fmt.Errorf("failed to get agent clone: %w", err)
+	}
+	
+	log.Printf("Agent %s working in clone: %s", agent.Name, clonePath)
+
+	// Refresh the clone with latest changes
+	if err := am.cloneManager.RefreshAgentClone(agent.Name); err != nil {
+		log.Printf("Warning: Failed to refresh clone for agent %s: %v", agent.Name, err)
+	}
+
+	// All Git operations use the agent's 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)
+		}
+	}
+
+	// Create branch
+	cmd = gitCmd("checkout", "-b", branchName)
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("failed to create branch: %w", err)
+	}
+
+	// Create solution file in agent's clone
+	solutionDir := filepath.Join(clonePath, "tasks", "solutions")
+	if err := os.MkdirAll(solutionDir, 0755); err != nil {
+		return fmt.Errorf("failed to create solution directory: %w", err)
+	}
+
+	solutionFile := filepath.Join(solutionDir, fmt.Sprintf("%s-solution.md", task.ID))
+	solutionContent := fmt.Sprintf(`# Solution for Task: %s
+
+**Agent:** %s (%s)  
+**Model:** %s  
+**Completed:** %s
+
+## Task Description
+%s
+
+## Solution
+%s
+
+---
+*Generated by Staff AI Agent System*
+`, task.Title, agent.Name, agent.Role, agent.Model, time.Now().Format(time.RFC3339), task.Description, solution)
+
+	if err := os.WriteFile(solutionFile, []byte(solutionContent), 0644); err != nil {
+		return fmt.Errorf("failed to write solution file: %w", err)
+	}
+
+	// Stage files
+	relativeSolutionFile := filepath.Join("tasks", "solutions", fmt.Sprintf("%s-solution.md", task.ID))
+	cmd = gitCmd("add", relativeSolutionFile)
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("failed to stage files: %w", err)
+	}
+
+	// Commit changes
+	commitMsg := am.buildCommitMessage(task, agent)
+	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("Agent %s successfully pushed branch %s", agent.Name, branchName)
+	return nil
+}
+
+// buildCommitMessage creates a commit message from template
+func (am *SimpleAgentManager) buildCommitMessage(task *tm.Task, agent *SimpleAgent) string {
+	template := am.config.Git.CommitMessageTemplate
+	
+	replacements := map[string]string{
+		"{task_id}":    task.ID,
+		"{task_title}": task.Title,
+		"{agent_name}": agent.Name,
+		"{solution}":   "See solution file for details",
+	}
+
+	result := template
+	for placeholder, value := range replacements {
+		result = strings.ReplaceAll(result, placeholder, value)
+	}
+
+	return result
+}
+
+// createPullRequest creates a GitHub pull request
+func (am *SimpleAgentManager) createPullRequest(ctx context.Context, task *tm.Task, solution string, agent *SimpleAgent, branchName string) (string, error) {
+	title := fmt.Sprintf("Task %s: %s", task.ID, task.Title)
+	
+	// Build PR description from template
+	description := am.buildPRDescription(task, solution, agent)
+	
+	options := git.PullRequestOptions{
+		Title:       title,
+		Description: description,
+		HeadBranch:  branchName,
+		BaseBranch:  "main",
+		Labels:      []string{"ai-generated", "staff-agent", strings.ToLower(agent.Role)},
+		Draft:       false,
+	}
+
+	pr, err := am.prProvider.CreatePullRequest(ctx, options)
+	if err != nil {
+		return "", fmt.Errorf("failed to create PR: %w", err)
+	}
+
+	return fmt.Sprintf("https://github.com/%s/%s/pull/%d", am.config.GitHub.Owner, am.config.GitHub.Repo, pr.Number), nil
+}
+
+// buildPRDescription creates PR description from template
+func (am *SimpleAgentManager) buildPRDescription(task *tm.Task, solution string, agent *SimpleAgent) string {
+	template := am.config.Git.PRTemplate
+	
+	// Truncate solution for PR if too long
+	truncatedSolution := solution
+	if len(solution) > 1000 {
+		truncatedSolution = solution[:1000] + "...\n\n*See solution file for complete details*"
+	}
+	
+	replacements := map[string]string{
+		"{task_id}":          task.ID,
+		"{task_title}":       task.Title,
+		"{task_description}": task.Description,
+		"{agent_name}":       fmt.Sprintf("%s (%s)", agent.Name, agent.Role),
+		"{priority}":         string(task.Priority),
+		"{solution}":         truncatedSolution,
+		"{files_changed}":    fmt.Sprintf("- `tasks/solutions/%s-solution.md`", task.ID),
+	}
+
+	result := template
+	for placeholder, value := range replacements {
+		result = strings.ReplaceAll(result, placeholder, value)
+	}
+
+	return result
+}
+
+// AutoAssignTask automatically assigns a task to the best matching agent
+func (am *SimpleAgentManager) AutoAssignTask(taskID string) error {
+	task, err := am.taskManager.GetTask(taskID)
+	if err != nil {
+		return fmt.Errorf("failed to get task: %w", err)
+	}
+
+	agentName, err := am.autoAssigner.AssignTask(task)
+	if err != nil {
+		return fmt.Errorf("failed to auto-assign task: %w", err)
+	}
+
+	task.Assignee = agentName
+	if err := am.taskManager.UpdateTask(task); err != nil {
+		return fmt.Errorf("failed to update task assignment: %w", err)
+	}
+
+	explanation := am.autoAssigner.GetRecommendationExplanation(task, agentName)
+	log.Printf("Auto-assigned task %s to %s: %s", taskID, agentName, explanation)
+
+	return nil
+}
+
+// GetAgentStatus returns the status of all agents
+func (am *SimpleAgentManager) GetAgentStatus() map[string]SimpleAgentStatus {
+	status := make(map[string]SimpleAgentStatus)
+	
+	for name, agent := range am.agents {
+		status[name] = SimpleAgentStatus{
+			Name:      agent.Name,
+			Role:      agent.Role,
+			Model:     agent.Model,
+			IsRunning: am.isRunning[name],
+		}
+	}
+	
+	return status
+}
+
+// SimpleAgentStatus represents the status of an agent
+type SimpleAgentStatus struct {
+	Name      string `json:"name"`
+	Role      string `json:"role"`
+	Model     string `json:"model"`
+	IsRunning bool   `json:"is_running"`
+}
+
+// IsAgentRunning checks if an agent is currently running
+func (am *SimpleAgentManager) IsAgentRunning(agentName string) bool {
+	return am.isRunning[agentName]
+}
+
+// Close shuts down the agent manager
+func (am *SimpleAgentManager) Close() error {
+	// Stop all running agents
+	for agentName := range am.isRunning {
+		if am.isRunning[agentName] {
+			am.StopAgent(agentName)
+		}
+	}
+
+	// Close all LLM providers
+	for _, agent := range am.agents {
+		if err := agent.Provider.Close(); err != nil {
+			log.Printf("Error closing provider for agent %s: %v", agent.Name, err)
+		}
+	}
+
+	// Cleanup all agent Git clones
+	if err := am.cloneManager.CleanupAllClones(); err != nil {
+		log.Printf("Error cleaning up agent clones: %v", err)
+	}
+
+	return nil
+}
\ No newline at end of file
diff --git a/server/assignment/auto_assignment.go b/server/assignment/auto_assignment.go
new file mode 100644
index 0000000..ed01be8
--- /dev/null
+++ b/server/assignment/auto_assignment.go
@@ -0,0 +1,237 @@
+package assignment
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+
+	"github.com/iomodo/staff/config"
+	"github.com/iomodo/staff/tm"
+)
+
+// AutoAssigner handles intelligent task assignment to agents
+type AutoAssigner struct {
+	agents []config.AgentConfig
+}
+
+// NewAutoAssigner creates a new auto-assignment system
+func NewAutoAssigner(agents []config.AgentConfig) *AutoAssigner {
+	return &AutoAssigner{
+		agents: agents,
+	}
+}
+
+// AssignmentScore represents how well an agent matches a task
+type AssignmentScore struct {
+	AgentName string
+	Score     float64
+	Reasons   []string
+}
+
+// AssignTask automatically assigns a task to the best matching agent
+func (a *AutoAssigner) AssignTask(task *tm.Task) (string, error) {
+	if len(a.agents) == 0 {
+		return "", fmt.Errorf("no agents available for assignment")
+	}
+
+	scores := a.calculateScores(task)
+	if len(scores) == 0 {
+		return "", fmt.Errorf("no suitable agent found for task")
+	}
+
+	// Sort by score (highest first)
+	sort.Slice(scores, func(i, j int) bool {
+		return scores[i].Score > scores[j].Score
+	})
+
+	bestMatch := scores[0]
+	if bestMatch.Score == 0 {
+		// No good match, assign to CEO as fallback
+		return "ceo", nil
+	}
+
+	return bestMatch.AgentName, nil
+}
+
+// GetAssignmentRecommendations returns ranked recommendations for task assignment
+func (a *AutoAssigner) GetAssignmentRecommendations(task *tm.Task) []AssignmentScore {
+	scores := a.calculateScores(task)
+	
+	// Sort by score (highest first)
+	sort.Slice(scores, func(i, j int) bool {
+		return scores[i].Score > scores[j].Score
+	})
+
+	return scores
+}
+
+// calculateScores calculates assignment scores for all agents
+func (a *AutoAssigner) calculateScores(task *tm.Task) []AssignmentScore {
+	scores := make([]AssignmentScore, 0, len(a.agents))
+
+	taskText := strings.ToLower(task.Title + " " + task.Description)
+	taskKeywords := extractKeywords(taskText)
+
+	for _, agent := range a.agents {
+		score := &AssignmentScore{
+			AgentName: agent.Name,
+			Score:     0,
+			Reasons:   make([]string, 0),
+		}
+
+		// Score based on task type keywords
+		score.Score += a.scoreTaskTypes(agent.TaskTypes, taskKeywords, score)
+		
+		// Score based on capabilities
+		score.Score += a.scoreCapabilities(agent.Capabilities, taskKeywords, score)
+		
+		// Score based on task priority and agent model
+		score.Score += a.scorePriorityModelMatch(task.Priority, agent.Model, score)
+		
+		// Score based on explicit agent mention in task
+		score.Score += a.scoreExplicitMention(agent.Name, agent.Role, taskText, score)
+
+		scores = append(scores, *score)
+	}
+
+	return scores
+}
+
+// scoreTaskTypes scores based on task type matching
+func (a *AutoAssigner) scoreTaskTypes(agentTypes []string, taskKeywords []string, score *AssignmentScore) float64 {
+	typeScore := 0.0
+	
+	for _, agentType := range agentTypes {
+		for _, keyword := range taskKeywords {
+			if strings.Contains(keyword, agentType) || strings.Contains(agentType, keyword) {
+				typeScore += 3.0
+				score.Reasons = append(score.Reasons, fmt.Sprintf("matches task type: %s", agentType))
+			}
+		}
+	}
+	
+	return typeScore
+}
+
+// scoreCapabilities scores based on capability matching
+func (a *AutoAssigner) scoreCapabilities(capabilities []string, taskKeywords []string, score *AssignmentScore) float64 {
+	capScore := 0.0
+	
+	for _, capability := range capabilities {
+		for _, keyword := range taskKeywords {
+			if strings.Contains(keyword, capability) || strings.Contains(capability, keyword) {
+				capScore += 2.0
+				score.Reasons = append(score.Reasons, fmt.Sprintf("has capability: %s", capability))
+			}
+		}
+	}
+	
+	return capScore
+}
+
+// scorePriorityModelMatch scores based on priority and model sophistication
+func (a *AutoAssigner) scorePriorityModelMatch(priority tm.TaskPriority, model string, score *AssignmentScore) float64 {
+	priorityScore := 0.0
+	
+	// High priority tasks prefer more capable models
+	if priority == tm.PriorityHigh && strings.Contains(model, "gpt-4") {
+		priorityScore += 1.0
+		score.Reasons = append(score.Reasons, "high priority task matches advanced model")
+	}
+	
+	// Medium/low priority can use efficient models
+	if priority != tm.PriorityHigh && strings.Contains(model, "gpt-3.5") {
+		priorityScore += 0.5
+		score.Reasons = append(score.Reasons, "priority matches model efficiency")
+	}
+	
+	return priorityScore
+}
+
+// scoreExplicitMention scores based on explicit agent/role mentions
+func (a *AutoAssigner) scoreExplicitMention(agentName, agentRole, taskText string, score *AssignmentScore) float64 {
+	mentionScore := 0.0
+	
+	// Check for explicit agent name mention
+	if strings.Contains(taskText, agentName) {
+		mentionScore += 5.0
+		score.Reasons = append(score.Reasons, "explicitly mentioned by name")
+	}
+	
+	// Check for role mention
+	roleLower := strings.ToLower(agentRole)
+	if strings.Contains(taskText, roleLower) {
+		mentionScore += 4.0
+		score.Reasons = append(score.Reasons, "role mentioned in task")
+	}
+	
+	return mentionScore
+}
+
+// extractKeywords extracts relevant keywords from task text
+func extractKeywords(text string) []string {
+	// Simple keyword extraction - split by common delimiters
+	words := strings.FieldsFunc(text, func(c rune) bool {
+		return c == ' ' || c == ',' || c == '.' || c == ':' || c == ';' || c == '\n' || c == '\t'
+	})
+	
+	// Filter out common stop words and short words
+	stopWords := map[string]bool{
+		"the": true, "a": true, "an": true, "and": true, "or": true, "but": true,
+		"in": true, "on": true, "at": true, "to": true, "for": true, "of": true,
+		"with": true, "by": true, "is": true, "are": true, "was": true, "were": true,
+		"be": true, "been": true, "have": true, "has": true, "had": true, "do": true,
+		"does": true, "did": true, "will": true, "would": true, "could": true, "should": true,
+	}
+	
+	keywords := make([]string, 0)
+	for _, word := range words {
+		word = strings.ToLower(strings.TrimSpace(word))
+		if len(word) > 2 && !stopWords[word] {
+			keywords = append(keywords, word)
+		}
+	}
+	
+	return keywords
+}
+
+// ValidateAssignment checks if an assignment is valid
+func (a *AutoAssigner) ValidateAssignment(agentName string, task *tm.Task) error {
+	// Check if agent exists
+	for _, agent := range a.agents {
+		if agent.Name == agentName {
+			return nil
+		}
+	}
+	
+	return fmt.Errorf("agent '%s' not found", agentName)
+}
+
+// GetAgentCapabilities returns the capabilities of a specific agent
+func (a *AutoAssigner) GetAgentCapabilities(agentName string) ([]string, error) {
+	for _, agent := range a.agents {
+		if agent.Name == agentName {
+			return agent.Capabilities, nil
+		}
+	}
+	
+	return nil, fmt.Errorf("agent '%s' not found", agentName)
+}
+
+// GetRecommendationExplanation returns a human-readable explanation for assignment
+func (a *AutoAssigner) GetRecommendationExplanation(task *tm.Task, agentName string) string {
+	recommendations := a.GetAssignmentRecommendations(task)
+	
+	for _, rec := range recommendations {
+		if rec.AgentName == agentName {
+			if len(rec.Reasons) == 0 {
+				return fmt.Sprintf("Agent %s assigned (score: %.1f)", agentName, rec.Score)
+			}
+			
+			reasons := strings.Join(rec.Reasons, ", ")
+			return fmt.Sprintf("Agent %s assigned (score: %.1f) because: %s", agentName, rec.Score, reasons)
+		}
+	}
+	
+	return fmt.Sprintf("Agent %s assigned (manual override)", agentName)
+}
\ No newline at end of file
diff --git a/server/cmd/commands/assign_task.go b/server/cmd/commands/assign_task.go
new file mode 100644
index 0000000..4bb6f75
--- /dev/null
+++ b/server/cmd/commands/assign_task.go
@@ -0,0 +1,43 @@
+package commands
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+)
+
+var assignTaskCmd = &cobra.Command{
+	Use:   "assign-task [task-id] [agent-name]",
+	Short: "Assign a task to an agent",
+	Long: `Assign an existing task to a specific agent.
+
+Examples:
+  staff assign-task task-1234567890-abcd1234 backend-engineer
+  staff assign-task task-1234567890-abcd1234 frontend-engineer`,
+	Args: cobra.ExactArgs(2),
+	RunE: runAssignTask,
+}
+
+func runAssignTask(cmd *cobra.Command, args []string) error {
+	taskID := args[0]
+	agentName := args[1]
+
+	// Get the task
+	task, err := taskManager.GetTask(taskID)
+	if err != nil {
+		return fmt.Errorf("failed to get task: %w", err)
+	}
+
+	// Assign the task
+	task.Assignee = agentName
+	if err := taskManager.UpdateTask(task); err != nil {
+		return fmt.Errorf("failed to assign task: %w", err)
+	}
+
+	fmt.Printf("Task %s assigned to %s successfully!\n", taskID, agentName)
+	fmt.Printf("Title: %s\n", task.Title)
+	fmt.Printf("Priority: %s\n", task.Priority)
+	fmt.Printf("Status: %s\n", task.Status)
+
+	return nil
+}
\ No newline at end of file
diff --git a/server/cmd/commands/cleanup_clones.go b/server/cmd/commands/cleanup_clones.go
new file mode 100644
index 0000000..344c4f3
--- /dev/null
+++ b/server/cmd/commands/cleanup_clones.go
@@ -0,0 +1,53 @@
+package commands
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+)
+
+var cleanupClonesCmd = &cobra.Command{
+	Use:   "cleanup-clones",
+	Short: "Clean up all agent Git clones",
+	Long: `Remove all agent Git clone directories to free up disk space.
+
+This command will:
+- Stop any running agents
+- Remove all agent-specific Git clone directories
+- Free up disk space used by clones
+
+Examples:
+  staff cleanup-clones`,
+	RunE: runCleanupClones,
+}
+
+// Note: Command is added in root.go init() function
+
+func runCleanupClones(cmd *cobra.Command, args []string) error {
+	if agentManager == nil {
+		return fmt.Errorf("agent manager not initialized")
+	}
+
+	// Stop all running agents first
+	fmt.Println("Stopping all running agents...")
+	for _, agent := range cfg.Agents {
+		if agentManager.IsAgentRunning(agent.Name) {
+			if err := agentManager.StopAgent(agent.Name); err != nil {
+				fmt.Printf("Warning: Failed to stop agent %s: %v\n", agent.Name, err)
+			} else {
+				fmt.Printf("Stopped agent: %s\n", agent.Name)
+			}
+		}
+	}
+
+	// Cleanup all clones by closing the agent manager
+	// This will trigger the cleanup automatically
+	if err := agentManager.Close(); err != nil {
+		return fmt.Errorf("failed to cleanup agent clones: %w", err)
+	}
+
+	fmt.Println("✅ All agent Git clones have been cleaned up successfully!")
+	fmt.Println("💡 Clones will be recreated automatically when agents start working on tasks")
+	
+	return nil
+}
\ No newline at end of file
diff --git a/server/cmd/commands/config_check.go b/server/cmd/commands/config_check.go
new file mode 100644
index 0000000..4813ee8
--- /dev/null
+++ b/server/cmd/commands/config_check.go
@@ -0,0 +1,81 @@
+package commands
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+)
+
+var configCheckCmd = &cobra.Command{
+	Use:   "config-check",
+	Short: "Check configuration validity",
+	Long: `Check the current configuration for errors and display settings.
+
+Examples:
+  staff config-check`,
+	RunE: runConfigCheck,
+}
+
+func runConfigCheck(cmd *cobra.Command, args []string) error {
+	fmt.Println("Configuration Check:")
+	fmt.Println("==================")
+
+	// Check OpenAI configuration
+	if cfg.OpenAI.APIKey == "" {
+		fmt.Println("❌ OpenAI API key is missing")
+	} else {
+		fmt.Printf("✅ OpenAI API key configured (ends with: ...%s)\n", cfg.OpenAI.APIKey[len(cfg.OpenAI.APIKey)-4:])
+	}
+
+	if cfg.OpenAI.BaseURL == "" {
+		fmt.Println("ℹ️  OpenAI Base URL using default")
+	} else {
+		fmt.Printf("ℹ️  OpenAI Base URL: %s\n", cfg.OpenAI.BaseURL)
+	}
+
+	// Check GitHub configuration
+	if cfg.GitHub.Token == "" {
+		fmt.Println("❌ GitHub token is missing")
+	} else {
+		fmt.Printf("✅ GitHub token configured (ends with: ...%s)\n", cfg.GitHub.Token[len(cfg.GitHub.Token)-4:])
+	}
+
+	if cfg.GitHub.Owner == "" {
+		fmt.Println("❌ GitHub owner is missing")
+	} else {
+		fmt.Printf("✅ GitHub owner: %s\n", cfg.GitHub.Owner)
+	}
+
+	if cfg.GitHub.Repo == "" {
+		fmt.Println("❌ GitHub repo is missing")
+	} else {
+		fmt.Printf("✅ GitHub repo: %s\n", cfg.GitHub.Repo)
+	}
+
+	// Check agents configuration
+	fmt.Printf("\nAgents: %d configured\n", len(cfg.Agents))
+	for i, agent := range cfg.Agents {
+		temp := 0.7
+		if agent.Temperature != nil {
+			temp = *agent.Temperature
+		}
+		fmt.Printf("  %d. %s (model: %s, temp: %.1f)\n", i+1, agent.Name, agent.Model, temp)
+	}
+
+	// Check task manager
+	if taskManager == nil {
+		fmt.Println("❌ Task manager not initialized")
+	} else {
+		fmt.Println("✅ Task manager initialized")
+	}
+
+	// Check agent manager
+	if agentManager == nil {
+		fmt.Println("❌ Agent manager not initialized")
+	} else {
+		fmt.Println("✅ Agent manager initialized")
+	}
+
+	fmt.Println("\nConfiguration check complete!")
+	return nil
+}
\ No newline at end of file
diff --git a/server/cmd/commands/create_task.go b/server/cmd/commands/create_task.go
new file mode 100644
index 0000000..4bb57d9
--- /dev/null
+++ b/server/cmd/commands/create_task.go
@@ -0,0 +1,89 @@
+package commands
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/iomodo/staff/tm"
+	"github.com/spf13/cobra"
+)
+
+var createTaskCmd = &cobra.Command{
+	Use:   "create-task [title]",
+	Short: "Create a new task",
+	Long: `Create a new task with specified title, description, and priority.
+
+Examples:
+  staff create-task "Add user authentication"
+  staff create-task "Fix login bug" --description "Users cannot log in with Google OAuth" --priority high --assignee backend-engineer`,
+	Args: cobra.ExactArgs(1),
+	RunE: runCreateTask,
+}
+
+var (
+	taskDescription string
+	taskPriority    string
+	taskAssignee    string
+	taskDueDate     string
+)
+
+func init() {
+	createTaskCmd.Flags().StringVarP(&taskDescription, "description", "d", "", "Task description")
+	createTaskCmd.Flags().StringVarP(&taskPriority, "priority", "p", "medium", "Task priority (low, medium, high)")
+	createTaskCmd.Flags().StringVarP(&taskAssignee, "assignee", "a", "", "Agent to assign the task to")
+	createTaskCmd.Flags().StringVar(&taskDueDate, "due", "", "Due date (RFC3339 format, e.g., 2024-01-15T10:00:00Z)")
+}
+
+func runCreateTask(cmd *cobra.Command, args []string) error {
+	title := args[0]
+	
+	// Validate priority
+	priority := tm.TaskPriority(taskPriority)
+	if priority != tm.PriorityLow && priority != tm.PriorityMedium && priority != tm.PriorityHigh {
+		return fmt.Errorf("invalid priority: %s (must be low, medium, or high)", taskPriority)
+	}
+
+	// Parse due date if provided
+	var dueDate *time.Time
+	if taskDueDate != "" {
+		parsed, err := time.Parse(time.RFC3339, taskDueDate)
+		if err != nil {
+			return fmt.Errorf("invalid due date format: %s (expected RFC3339)", taskDueDate)
+		}
+		dueDate = &parsed
+	}
+
+	// Create task request
+	req := &tm.TaskCreateRequest{
+		Title:       title,
+		Description: taskDescription,
+		OwnerID:     "user", // MVP: single user
+		Priority:    priority,
+		DueDate:     dueDate,
+	}
+
+	// Create the task
+	task, err := taskManager.CreateTask(context.Background(), req)
+	if err != nil {
+		return fmt.Errorf("failed to create task: %w", err)
+	}
+
+	fmt.Printf("Task created successfully!\n")
+	fmt.Printf("ID: %s\n", task.ID)
+	fmt.Printf("Title: %s\n", task.Title)
+	fmt.Printf("Priority: %s\n", task.Priority)
+	fmt.Printf("Status: %s\n", task.Status)
+	
+	// Auto-assign if assignee is specified
+	if taskAssignee != "" {
+		task.Assignee = taskAssignee
+		if err := taskManager.UpdateTask(task); err != nil {
+			fmt.Printf("Warning: Failed to assign task to %s: %v\n", taskAssignee, err)
+		} else {
+			fmt.Printf("Assigned to: %s\n", taskAssignee)
+		}
+	}
+
+	return nil
+}
\ No newline at end of file
diff --git a/server/cmd/commands/list_agents.go b/server/cmd/commands/list_agents.go
new file mode 100644
index 0000000..7d0ac86
--- /dev/null
+++ b/server/cmd/commands/list_agents.go
@@ -0,0 +1,63 @@
+package commands
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/spf13/cobra"
+)
+
+var listAgentsCmd = &cobra.Command{
+	Use:   "list-agents",
+	Short: "List all configured agents",
+	Long: `List all configured agents with their settings and status.
+
+Examples:
+  staff list-agents`,
+	RunE: runListAgents,
+}
+
+func runListAgents(cmd *cobra.Command, args []string) error {
+	if len(cfg.Agents) == 0 {
+		fmt.Println("No agents configured")
+		return nil
+	}
+
+	fmt.Printf("Found %d configured agents:\n\n", len(cfg.Agents))
+
+	// Display agents in table format
+	fmt.Printf("%-20s %-15s %-12s %-10s %-30s\n", "Name", "Model", "Temperature", "Status", "Role/Description")
+	fmt.Printf("%s\n", strings.Repeat("-", 90))
+
+	for _, agent := range cfg.Agents {
+		status := "stopped"
+		if agentManager.IsAgentRunning(agent.Name) {
+			status = "running"
+		}
+
+		role := agent.Role
+		if role == "" {
+			role = "general"
+		}
+		if len(role) > 27 {
+			role = role[:27] + "..."
+		}
+
+		temp := 0.7
+		if agent.Temperature != nil {
+			temp = *agent.Temperature
+		}
+
+		fmt.Printf("%-20s %-15s %-12.1f %-10s %-30s\n", 
+			agent.Name, 
+			agent.Model, 
+			temp, 
+			status,
+			role)
+	}
+
+	fmt.Printf("\nUse 'staff start-agent <agent-name>' to start an agent\n")
+	fmt.Printf("Use 'staff stop-agent <agent-name>' to stop a running agent\n")
+
+	return nil
+}
\ No newline at end of file
diff --git a/server/cmd/commands/list_tasks.go b/server/cmd/commands/list_tasks.go
new file mode 100644
index 0000000..09cc20b
--- /dev/null
+++ b/server/cmd/commands/list_tasks.go
@@ -0,0 +1,109 @@
+package commands
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/iomodo/staff/tm"
+	"github.com/spf13/cobra"
+)
+
+var listTasksCmd = &cobra.Command{
+	Use:   "list-tasks",
+	Short: "List all tasks",
+	Long: `List all tasks with optional filtering by status, priority, or assignee.
+
+Examples:
+  staff list-tasks
+  staff list-tasks --status todo
+  staff list-tasks --priority high
+  staff list-tasks --assignee backend-engineer`,
+	RunE: runListTasks,
+}
+
+var (
+	filterStatus   string
+	filterPriority string
+	filterAssignee string
+	pageSize       int = 20
+	pageNum        int = 0
+)
+
+func init() {
+	listTasksCmd.Flags().StringVar(&filterStatus, "status", "", "Filter by status (todo, in_progress, completed, archived)")
+	listTasksCmd.Flags().StringVar(&filterPriority, "priority", "", "Filter by priority (low, medium, high)")
+	listTasksCmd.Flags().StringVar(&filterAssignee, "assignee", "", "Filter by assignee")
+	listTasksCmd.Flags().IntVar(&pageSize, "page-size", 20, "Number of tasks per page")
+	listTasksCmd.Flags().IntVar(&pageNum, "page", 0, "Page number (0-based)")
+}
+
+func runListTasks(cmd *cobra.Command, args []string) error {
+	// Build filter
+	filter := &tm.TaskFilter{}
+	
+	if filterStatus != "" {
+		status := tm.TaskStatus(filterStatus)
+		filter.Status = &status
+	}
+	
+	if filterPriority != "" {
+		priority := tm.TaskPriority(filterPriority)
+		filter.Priority = &priority
+	}
+
+	// Get tasks
+	taskList, err := taskManager.ListTasks(context.Background(), filter, pageNum, pageSize)
+	if err != nil {
+		return fmt.Errorf("failed to list tasks: %w", err)
+	}
+
+	// Filter by assignee if specified (not in TaskFilter interface yet)
+	var filteredTasks []*tm.Task
+	if filterAssignee != "" {
+		for _, task := range taskList.Tasks {
+			if task.Assignee == filterAssignee {
+				filteredTasks = append(filteredTasks, task)
+			}
+		}
+	} else {
+		filteredTasks = taskList.Tasks
+	}
+
+	// Display results
+	if len(filteredTasks) == 0 {
+		fmt.Println("No tasks found")
+		return nil
+	}
+
+	fmt.Printf("Found %d tasks (page %d/%d)\n\n", len(filteredTasks), pageNum+1, (taskList.TotalCount+pageSize-1)/pageSize)
+
+	// Display tasks in table format
+	fmt.Printf("%-20s %-10s %-10s %-15s %-50s\n", "ID", "Status", "Priority", "Assignee", "Title")
+	fmt.Printf("%s\n", strings.Repeat("-", 110))
+
+	for _, task := range filteredTasks {
+		assignee := task.Assignee
+		if assignee == "" {
+			assignee = "unassigned"
+		}
+		
+		title := task.Title
+		if len(title) > 47 {
+			title = title[:47] + "..."
+		}
+
+		fmt.Printf("%-20s %-10s %-10s %-15s %-50s\n", 
+			task.ID, 
+			string(task.Status), 
+			string(task.Priority), 
+			assignee, 
+			title)
+	}
+
+	if taskList.HasMore {
+		fmt.Printf("\nUse --page %d to see more tasks\n", pageNum+1)
+	}
+
+	return nil
+}
\ No newline at end of file
diff --git a/server/cmd/commands/root.go b/server/cmd/commands/root.go
index 088e7ff..165d109 100644
--- a/server/cmd/commands/root.go
+++ b/server/cmd/commands/root.go
@@ -1,62 +1,88 @@
 package commands
 
 import (
+	"fmt"
 	"log/slog"
 	"os"
-	"os/signal"
-	"syscall"
 
-	"github.com/iomodo/staff/server"
+	"github.com/iomodo/staff/agent"
+	"github.com/iomodo/staff/config"
+	"github.com/iomodo/staff/git"
+	"github.com/iomodo/staff/tm"
+	"github.com/iomodo/staff/tm/git_tm"
 	"github.com/spf13/cobra"
 )
 
 // Command is an abstraction of the cobra Command
 type Command = cobra.Command
 
+// Global variables for the MVP
+var (
+	agentManager *agent.SimpleAgentManager
+	taskManager  tm.TaskManager
+	cfg          *config.Config
+)
+
 // Run function starts the application
 func Run(args []string) error {
 	rootCmd.SetArgs(args)
 	return rootCmd.Execute()
 }
 
-// rootCmd is a command to run the server.
+// rootCmd is the main command for Staff MVP
 var rootCmd = &cobra.Command{
-	Use:   "server",
-	Short: "Runs a server",
-	Long:  `Runs a server. Killing the process will stop the server`,
-	RunE:  serverCmdF,
+	Use:   "staff",
+	Short: "Staff - AI Multi-Agent Development System",
+	Long: `Staff MVP - AI agents that autonomously handle development tasks and create GitHub PRs.
+
+Examples:
+  staff create-task "Add user authentication" --priority high --agent backend-engineer
+  staff start-agent backend-engineer
+  staff list-tasks
+  staff list-agents`,
+	PersistentPreRunE: initializeApp,
 }
 
-func serverCmdF(_ *cobra.Command, _ []string) error {
-	srv, err := runServer()
-	if err != nil {
-		return err
+func init() {
+	// Add all commands
+	rootCmd.AddCommand(createTaskCmd)
+	rootCmd.AddCommand(assignTaskCmd)
+	rootCmd.AddCommand(startAgentCmd)
+	rootCmd.AddCommand(stopAgentCmd)
+	rootCmd.AddCommand(listTasksCmd)
+	rootCmd.AddCommand(listAgentsCmd)
+	rootCmd.AddCommand(configCheckCmd)
+	rootCmd.AddCommand(cleanupClonesCmd)
+	rootCmd.AddCommand(versionCmd)
+}
+
+// initializeApp loads configuration and sets up managers
+func initializeApp(cmd *cobra.Command, args []string) error {
+	// Skip initialization for help and version commands
+	if cmd.Name() == "help" || cmd.Name() == "version" {
+		return nil
 	}
-	defer srv.Shutdown()
 
-	// wait for kill signal before attempting to gracefully shutdown
-	// the running service
-	interruptChan := make(chan os.Signal, 1)
-	signal.Notify(interruptChan, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
-	<-interruptChan
-	return nil
-}
+	// Load configuration
+	var err error
+	cfg, err = config.LoadConfigWithEnvOverrides("config.yaml")
+	if err != nil {
+		return fmt.Errorf("failed to load config: %w", err)
+	}
 
-func runServer() (*server.Server, error) {
+	// Initialize task manager
 	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
-		Level: slog.LevelDebug,
+		Level: slog.LevelInfo,
 	}))
 
-	srv, err := server.NewServer(logger)
+	gitInterface := git.DefaultGit(".")
+	taskManager = git_tm.NewGitTaskManagerWithLogger(gitInterface, ".", logger)
+
+	// Initialize agent manager
+	agentManager, err = agent.NewSimpleAgentManager(cfg, taskManager)
 	if err != nil {
-		logger.Error(err.Error())
-		return nil, err
+		return fmt.Errorf("failed to initialize agent manager: %w", err)
 	}
 
-	serverErr := srv.Start()
-	if serverErr != nil {
-		logger.Error(serverErr.Error())
-		return nil, serverErr
-	}
-	return srv, nil
+	return nil
 }
diff --git a/server/cmd/commands/start_agent.go b/server/cmd/commands/start_agent.go
new file mode 100644
index 0000000..8c951c8
--- /dev/null
+++ b/server/cmd/commands/start_agent.go
@@ -0,0 +1,84 @@
+package commands
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/spf13/cobra"
+)
+
+var startAgentCmd = &cobra.Command{
+	Use:   "start-agent [agent-name]",
+	Short: "Start an agent to process tasks",
+	Long: `Start a specific agent to continuously process assigned tasks.
+
+The agent will:
+1. Check for assigned tasks every 30 seconds
+2. Process tasks using the configured LLM
+3. Create GitHub PRs for solutions
+4. Mark tasks as completed
+
+Examples:
+  staff start-agent backend-engineer
+  staff start-agent frontend-engineer`,
+	Args: cobra.ExactArgs(1),
+	RunE: runStartAgent,
+}
+
+var (
+	agentInterval time.Duration = 30 * time.Second
+)
+
+func init() {
+	startAgentCmd.Flags().DurationVar(&agentInterval, "interval", 30*time.Second, "Task check interval")
+}
+
+func runStartAgent(cmd *cobra.Command, args []string) error {
+	agentName := args[0]
+
+	// Check if agent exists in configuration
+	var agentExists bool
+	for _, agent := range cfg.Agents {
+		if agent.Name == agentName {
+			agentExists = true
+			break
+		}
+	}
+
+	if !agentExists {
+		return fmt.Errorf("agent '%s' not found in configuration", agentName)
+	}
+
+	fmt.Printf("Starting agent: %s\n", agentName)
+	fmt.Printf("Task check interval: %v\n", agentInterval)
+	fmt.Printf("Press Ctrl+C to stop the agent\n\n")
+
+	// Set up signal handling for graceful shutdown
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
+
+	go func() {
+		<-sigChan
+		fmt.Printf("\nReceived shutdown signal, stopping agent...\n")
+		cancel()
+	}()
+
+	// Start the agent
+	err := agentManager.StartAgent(agentName, agentInterval)
+	if err != nil {
+		return fmt.Errorf("failed to start agent: %w", err)
+	}
+
+	// Wait for context cancellation (Ctrl+C)
+	<-ctx.Done()
+
+	fmt.Printf("Agent %s stopped\n", agentName)
+	return nil
+}
\ No newline at end of file
diff --git a/server/cmd/commands/stop_agent.go b/server/cmd/commands/stop_agent.go
new file mode 100644
index 0000000..e80d527
--- /dev/null
+++ b/server/cmd/commands/stop_agent.go
@@ -0,0 +1,31 @@
+package commands
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+)
+
+var stopAgentCmd = &cobra.Command{
+	Use:   "stop-agent [agent-name]",
+	Short: "Stop a running agent",
+	Long: `Stop a specific running agent.
+
+Examples:
+  staff stop-agent backend-engineer
+  staff stop-agent frontend-engineer`,
+	Args: cobra.ExactArgs(1),
+	RunE: runStopAgent,
+}
+
+func runStopAgent(cmd *cobra.Command, args []string) error {
+	agentName := args[0]
+
+	err := agentManager.StopAgent(agentName)
+	if err != nil {
+		return fmt.Errorf("failed to stop agent: %w", err)
+	}
+
+	fmt.Printf("Agent %s stopped successfully\n", agentName)
+	return nil
+}
\ No newline at end of file
diff --git a/server/cmd/commands/version.go b/server/cmd/commands/version.go
new file mode 100644
index 0000000..b6f2720
--- /dev/null
+++ b/server/cmd/commands/version.go
@@ -0,0 +1,27 @@
+package commands
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+)
+
+const (
+	Version   = "0.1.0"
+	BuildDate = "2024-01-15"
+	GitCommit = "mvp-build"
+)
+
+var versionCmd = &cobra.Command{
+	Use:   "version",
+	Short: "Show version information",
+	Long:  `Display the current version of Staff MVP.`,
+	Run:   runVersion,
+}
+
+func runVersion(cmd *cobra.Command, args []string) {
+	fmt.Printf("Staff MVP v%s\n", Version)
+	fmt.Printf("Built: %s\n", BuildDate)
+	fmt.Printf("Commit: %s\n", GitCommit)
+	fmt.Printf("AI Multi-Agent Development System\n")
+}
\ No newline at end of file
diff --git a/server/config.yaml b/server/config.yaml
new file mode 100644
index 0000000..2bd6482
--- /dev/null
+++ b/server/config.yaml
@@ -0,0 +1,43 @@
+# Staff MVP Configuration
+# This is a minimal config for testing the MVP
+
+openai:
+  api_key: "${OPENAI_API_KEY}"
+  base_url: ""
+  timeout: "60s"
+
+github:
+  token: "${GITHUB_TOKEN}"
+  owner: "shota"  # Replace with your GitHub username
+  repo: "staff"   # Replace with your repository name
+
+git:
+  branch_prefix: "task/"
+  commit_message_template: "Task {task_id}: {task_title} by {agent_name}"
+  pr_template: |
+    ## Task: {task_title}
+    
+    **Priority:** {priority}  
+    **Task ID:** {task_id}  
+    **Agent:** {agent_name}
+    
+    ### Description
+    {task_description}
+    
+    ### Solution
+    {solution}
+    
+    ### Files Changed
+    {files_changed}
+    
+    ---
+    *This PR was automatically generated by Staff AI Agent System*
+
+# Simplified agent configuration for MVP testing
+agents:
+  - name: "backend-engineer"
+    role: "Backend Engineer"
+    model: "gpt-4"
+    temperature: 0.3
+    max_tokens: 4000
+    system_prompt_file: "operations/agents/backend-engineer/system.md"
\ No newline at end of file
diff --git a/server/config/config.go b/server/config/config.go
new file mode 100644
index 0000000..84441d2
--- /dev/null
+++ b/server/config/config.go
@@ -0,0 +1,234 @@
+package config
+
+import (
+	"fmt"
+	"os"
+	"time"
+
+	"gopkg.in/yaml.v3"
+)
+
+// Config represents the Staff MVP configuration
+type Config struct {
+	OpenAI OpenAIConfig `yaml:"openai"`
+	GitHub GitHubConfig `yaml:"github"`
+	Agents []AgentConfig `yaml:"agents"`
+	Tasks  TasksConfig   `yaml:"tasks"`
+	Git    GitConfig     `yaml:"git"`
+}
+
+// OpenAIConfig represents OpenAI provider configuration
+type OpenAIConfig struct {
+	APIKey     string        `yaml:"api_key"`
+	Model      string        `yaml:"model"`
+	BaseURL    string        `yaml:"base_url"`
+	Timeout    time.Duration `yaml:"timeout"`
+	MaxRetries int           `yaml:"max_retries"`
+}
+
+// GitHubConfig represents GitHub integration configuration
+type GitHubConfig struct {
+	Token string `yaml:"token"`
+	Owner string `yaml:"owner"`
+	Repo  string `yaml:"repo"`
+}
+
+// AgentConfig represents individual agent configuration
+type AgentConfig struct {
+	Name             string   `yaml:"name"`
+	Role             string   `yaml:"role"`
+	Model            string   `yaml:"model"`
+	SystemPromptFile string   `yaml:"system_prompt_file"`
+	Capabilities     []string `yaml:"capabilities"`     // For auto-assignment
+	TaskTypes        []string `yaml:"task_types"`       // Types of tasks this agent handles
+	MaxTokens        *int     `yaml:"max_tokens"`       // Model-specific token limits
+	Temperature      *float64 `yaml:"temperature"`      // Model creativity setting
+}
+
+// TasksConfig represents task management configuration
+type TasksConfig struct {
+	StoragePath   string `yaml:"storage_path"`
+	CompletedPath string `yaml:"completed_path"`
+}
+
+// GitConfig represents Git operation configuration
+type GitConfig struct {
+	BranchPrefix          string `yaml:"branch_prefix"`
+	CommitMessageTemplate string `yaml:"commit_message_template"`
+	PRTemplate            string `yaml:"pr_template"`
+}
+
+// LoadConfig loads configuration from a YAML file
+func LoadConfig(configPath string) (*Config, error) {
+	// Read the config file
+	data, err := os.ReadFile(configPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read config file: %w", err)
+	}
+
+	// Parse YAML
+	var config Config
+	if err := yaml.Unmarshal(data, &config); err != nil {
+		return nil, fmt.Errorf("failed to parse config YAML: %w", err)
+	}
+
+	// Apply defaults
+	config = applyDefaults(config)
+
+	// Validate configuration
+	if err := validateConfig(config); err != nil {
+		return nil, fmt.Errorf("invalid configuration: %w", err)
+	}
+
+	return &config, nil
+}
+
+// LoadConfigWithEnvOverrides loads config with environment variable overrides
+func LoadConfigWithEnvOverrides(configPath string) (*Config, error) {
+	config, err := LoadConfig(configPath)
+	if err != nil {
+		return nil, err
+	}
+
+	// Override with environment variables if present
+	if apiKey := os.Getenv("OPENAI_API_KEY"); apiKey != "" {
+		config.OpenAI.APIKey = apiKey
+	}
+	if githubToken := os.Getenv("GITHUB_TOKEN"); githubToken != "" {
+		config.GitHub.Token = githubToken
+	}
+	if owner := os.Getenv("GITHUB_OWNER"); owner != "" {
+		config.GitHub.Owner = owner
+	}
+	if repo := os.Getenv("GITHUB_REPO"); repo != "" {
+		config.GitHub.Repo = repo
+	}
+
+	// Re-validate after env overrides
+	if err := validateConfig(*config); err != nil {
+		return nil, fmt.Errorf("invalid configuration after env overrides: %w", err)
+	}
+
+	return config, nil
+}
+
+// applyDefaults applies default values to configuration
+func applyDefaults(config Config) Config {
+	// OpenAI defaults
+	if config.OpenAI.Model == "" {
+		config.OpenAI.Model = "gpt-4"
+	}
+	if config.OpenAI.BaseURL == "" {
+		config.OpenAI.BaseURL = "https://api.openai.com/v1"
+	}
+	if config.OpenAI.Timeout == 0 {
+		config.OpenAI.Timeout = 30 * time.Second
+	}
+	if config.OpenAI.MaxRetries == 0 {
+		config.OpenAI.MaxRetries = 3
+	}
+
+	// Tasks defaults
+	if config.Tasks.StoragePath == "" {
+		config.Tasks.StoragePath = "tasks/"
+	}
+	if config.Tasks.CompletedPath == "" {
+		config.Tasks.CompletedPath = "tasks/completed/"
+	}
+
+	// Git defaults
+	if config.Git.BranchPrefix == "" {
+		config.Git.BranchPrefix = "task/"
+	}
+	if config.Git.CommitMessageTemplate == "" {
+		config.Git.CommitMessageTemplate = "Task {task_id}: {task_title}\n\n{solution}\n\nGenerated by Staff AI Agent: {agent_name}"
+	}
+	if config.Git.PRTemplate == "" {
+		config.Git.PRTemplate = `## Task: {task_title}
+
+**Task ID:** {task_id}  
+**Agent:** {agent_name}  
+**Priority:** {priority}
+
+### Description
+{task_description}
+
+### Solution
+{solution}
+
+### Files Changed
+{files_changed}
+
+---
+*Generated by Staff AI Multi-Agent System*`
+	}
+
+	// Agent defaults
+	for i := range config.Agents {
+		if config.Agents[i].Model == "" {
+			config.Agents[i].Model = config.OpenAI.Model
+		}
+	}
+
+	return config
+}
+
+// validateConfig validates the configuration
+func validateConfig(config Config) error {
+	// Validate OpenAI config
+	if config.OpenAI.APIKey == "" {
+		return fmt.Errorf("openai.api_key is required")
+	}
+	if config.OpenAI.Model == "" {
+		return fmt.Errorf("openai.model is required")
+	}
+
+	// Validate GitHub config
+	if config.GitHub.Token == "" {
+		return fmt.Errorf("github.token is required")
+	}
+	if config.GitHub.Owner == "" {
+		return fmt.Errorf("github.owner is required")
+	}
+	if config.GitHub.Repo == "" {
+		return fmt.Errorf("github.repo is required")
+	}
+
+	// Validate agents
+	if len(config.Agents) == 0 {
+		return fmt.Errorf("at least one agent must be configured")
+	}
+
+	for i, agent := range config.Agents {
+		if agent.Name == "" {
+			return fmt.Errorf("agent[%d].name is required", i)
+		}
+		if agent.Role == "" {
+			return fmt.Errorf("agent[%d].role is required", i)
+		}
+		if agent.SystemPromptFile == "" {
+			return fmt.Errorf("agent[%d].system_prompt_file is required", i)
+		}
+	}
+
+	return nil
+}
+
+// GetAgentByName returns an agent config by name
+func (c *Config) GetAgentByName(name string) (*AgentConfig, error) {
+	for _, agent := range c.Agents {
+		if agent.Name == name {
+			return &agent, nil
+		}
+	}
+	return nil, fmt.Errorf("agent not found: %s", name)
+}
+
+// ListAgentNames returns a list of all configured agent names
+func (c *Config) ListAgentNames() []string {
+	names := make([]string, len(c.Agents))
+	for i, agent := range c.Agents {
+		names[i] = agent.Name
+	}
+	return names
+}
\ No newline at end of file
diff --git a/server/config/openai_test.go b/server/config/openai_test.go
new file mode 100644
index 0000000..bd53e9c
--- /dev/null
+++ b/server/config/openai_test.go
@@ -0,0 +1,202 @@
+package config
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/iomodo/staff/llm"
+	"github.com/iomodo/staff/llm/openai"
+)
+
+// TestOpenAIIntegration tests the OpenAI integration with real API calls
+// This test requires OPENAI_API_KEY environment variable to be set
+func TestOpenAIIntegration(t *testing.T) {
+	apiKey := os.Getenv("OPENAI_API_KEY")
+	if apiKey == "" {
+		t.Skip("OPENAI_API_KEY not set, skipping OpenAI integration test")
+	}
+
+	// Create OpenAI config
+	config := llm.Config{
+		Provider: llm.ProviderOpenAI,
+		APIKey:   apiKey,
+		BaseURL:  "https://api.openai.com/v1",
+	}
+
+	// Create OpenAI provider
+	factory := &openai.OpenAIFactory{}
+	provider, err := factory.CreateProvider(config)
+	if err != nil {
+		t.Fatalf("Failed to create OpenAI provider: %v", err)
+	}
+	defer provider.Close()
+
+	// Test chat completion
+	t.Run("ChatCompletion", func(t *testing.T) {
+		req := llm.ChatCompletionRequest{
+			Model: "gpt-3.5-turbo",
+			Messages: []llm.Message{
+				{
+					Role:    llm.RoleSystem,
+					Content: "You are a helpful assistant.",
+				},
+				{
+					Role:    llm.RoleUser,
+					Content: "Hello! Just say 'Hello from OpenAI' and nothing else.",
+				},
+			},
+		}
+
+		resp, err := provider.ChatCompletion(context.Background(), req)
+		if err != nil {
+			t.Fatalf("ChatCompletion failed: %v", err)
+		}
+
+		if len(resp.Choices) == 0 {
+			t.Fatal("No choices returned")
+		}
+
+		message := resp.Choices[0].Message
+		if message.Content == "" {
+			t.Fatal("Empty response content")
+		}
+
+		t.Logf("OpenAI Response: %s", message.Content)
+	})
+
+	// Test embeddings
+	t.Run("Embeddings", func(t *testing.T) {
+		req := llm.EmbeddingRequest{
+			Model: "text-embedding-ada-002",
+			Input: "Hello, world!",
+		}
+
+		resp, err := provider.CreateEmbeddings(context.Background(), req)
+		if err != nil {
+			t.Fatalf("CreateEmbeddings failed: %v", err)
+		}
+
+		if len(resp.Data) == 0 {
+			t.Fatal("No embeddings returned")
+		}
+
+		embedding := resp.Data[0]
+		if len(embedding.Embedding) == 0 {
+			t.Fatal("Empty embedding vector")
+		}
+
+		t.Logf("Embedding dimensions: %d", len(embedding.Embedding))
+	})
+}
+
+// TestConfigurationLoading tests the configuration loading functionality
+func TestConfigurationLoading(t *testing.T) {
+	// Create a temporary config file
+	configContent := `
+openai:
+  api_key: "test-key"
+  model: "gpt-4"
+  
+github:
+  token: "test-token"
+  owner: "test-owner"
+  repo: "test-repo"
+  
+agents:
+  - name: "ceo"
+    role: "CEO"
+    system_prompt_file: "operations/agents/ceo/system.md"
+    
+tasks:
+  storage_path: "tasks/"
+`
+
+	// Write temp config file
+	tmpFile, err := os.CreateTemp("", "staff-config-*.yaml")
+	if err != nil {
+		t.Fatalf("Failed to create temp file: %v", err)
+	}
+	defer os.Remove(tmpFile.Name())
+
+	if _, err := tmpFile.WriteString(configContent); err != nil {
+		t.Fatalf("Failed to write config: %v", err)
+	}
+	tmpFile.Close()
+
+	// Test loading config
+	config, err := LoadConfig(tmpFile.Name())
+	if err != nil {
+		t.Fatalf("Failed to load config: %v", err)
+	}
+
+	// Validate loaded config
+	if config.OpenAI.APIKey != "test-key" {
+		t.Errorf("Expected API key 'test-key', got '%s'", config.OpenAI.APIKey)
+	}
+
+	if config.OpenAI.Model != "gpt-4" {
+		t.Errorf("Expected model 'gpt-4', got '%s'", config.OpenAI.Model)
+	}
+
+	if len(config.Agents) != 1 {
+		t.Errorf("Expected 1 agent, got %d", len(config.Agents))
+	}
+
+	if config.Agents[0].Name != "ceo" {
+		t.Errorf("Expected agent name 'ceo', got '%s'", config.Agents[0].Name)
+	}
+}
+
+// TestEnvironmentOverrides tests environment variable overrides
+func TestEnvironmentOverrides(t *testing.T) {
+	// Set environment variables
+	os.Setenv("OPENAI_API_KEY", "env-openai-key")
+	os.Setenv("GITHUB_TOKEN", "env-github-token")
+	defer func() {
+		os.Unsetenv("OPENAI_API_KEY")
+		os.Unsetenv("GITHUB_TOKEN")
+	}()
+
+	// Create a temporary config file
+	configContent := `
+openai:
+  api_key: "config-key"
+  
+github:
+  token: "config-token"
+  owner: "test-owner"
+  repo: "test-repo"
+  
+agents:
+  - name: "ceo"
+    role: "CEO"
+    system_prompt_file: "operations/agents/ceo/system.md"
+`
+
+	tmpFile, err := os.CreateTemp("", "staff-config-*.yaml")
+	if err != nil {
+		t.Fatalf("Failed to create temp file: %v", err)
+	}
+	defer os.Remove(tmpFile.Name())
+
+	if _, err := tmpFile.WriteString(configContent); err != nil {
+		t.Fatalf("Failed to write config: %v", err)
+	}
+	tmpFile.Close()
+
+	// Test loading config with env overrides
+	config, err := LoadConfigWithEnvOverrides(tmpFile.Name())
+	if err != nil {
+		t.Fatalf("Failed to load config: %v", err)
+	}
+
+	// Verify environment overrides
+	if config.OpenAI.APIKey != "env-openai-key" {
+		t.Errorf("Expected env API key 'env-openai-key', got '%s'", config.OpenAI.APIKey)
+	}
+
+	if config.GitHub.Token != "env-github-token" {
+		t.Errorf("Expected env GitHub token 'env-github-token', got '%s'", config.GitHub.Token)
+	}
+}
\ No newline at end of file
diff --git a/server/git/CONCURRENCY_README.md b/server/git/CONCURRENCY_README.md
new file mode 100644
index 0000000..1cbe184
--- /dev/null
+++ b/server/git/CONCURRENCY_README.md
@@ -0,0 +1,172 @@
+# Git Concurrency Solution: Per-Agent Repository Clones
+
+## Problem Statement
+
+Git is not thread-safe, which creates critical race conditions when multiple AI agents try to perform Git operations concurrently:
+
+- **Repository Corruption**: Multiple agents modifying the same `.git` folder simultaneously
+- **Branch Conflicts**: Agents creating branches with the same names or overwriting each other's work  
+- **Push Failures**: Concurrent pushes causing merge conflicts and failed operations
+- **Index Lock Errors**: Git index.lock conflicts when multiple processes access the repository
+
+## Solution: Per-Agent Git Clones
+
+Instead of using mutexes (which would serialize all Git operations and hurt performance), we give each agent its own Git repository clone:
+
+```
+workspace/
+├── agent-backend-engineer/     # Backend engineer's clone
+│   ├── .git/
+│   ├── tasks/
+│   └── ...
+├── agent-frontend-engineer/    # Frontend engineer's clone  
+│   ├── .git/
+│   ├── tasks/
+│   └── ...
+└── agent-qa-engineer/         # QA engineer's clone
+    ├── .git/
+    ├── tasks/
+    └── ...
+```
+
+## Key Benefits
+
+### 🚀 **True Concurrency**
+- Multiple agents can work simultaneously without blocking each other
+- No waiting for Git lock releases
+- Scales to hundreds of concurrent agents
+
+### 🛡️ **Complete Isolation** 
+- Each agent has its own `.git` directory and working tree
+- No shared state or race conditions
+- Agent failures don't affect other agents
+
+### 🔄 **Automatic Synchronization**
+- Each clone automatically pulls latest changes before creating branches
+- All branches push to the same remote repository
+- PRs are created against the main repository
+
+### 🧹 **Easy Cleanup**
+- `staff cleanup-clones` removes all agent workspaces
+- Clones are recreated on-demand when agents start working
+- No manual Git state management required
+
+## Implementation Details
+
+### CloneManager (`git/clone_manager.go`)
+
+```go
+type CloneManager struct {
+    baseRepoURL    string                // Source repository URL
+    workspacePath  string                // Base workspace directory  
+    agentClones    map[string]string     // agent name -> clone path
+    mu             sync.RWMutex          // Thread-safe map access
+}
+```
+
+**Key Methods:**
+- `GetAgentClonePath(agentName)` - Get/create agent's clone directory
+- `RefreshAgentClone(agentName)` - Pull latest changes for an agent
+- `CleanupAgentClone(agentName)` - Remove specific agent's clone
+- `CleanupAllClones()` - Remove all agent clones
+
+### Agent Integration
+
+Each agent's Git operations are automatically routed to its dedicated clone:
+
+```go
+// Get agent's dedicated Git clone
+clonePath, err := am.cloneManager.GetAgentClonePath(agent.Name)
+if err != nil {
+    return fmt.Errorf("failed to get agent clone: %w", err)
+}
+
+// All Git operations use the agent's clone directory
+gitCmd := func(args ...string) *exec.Cmd {
+    return exec.CommandContext(ctx, "git", append([]string{"-C", clonePath}, args...)...)
+}
+```
+
+## Workflow Example
+
+1. **Agent Starts Task**:
+   ```bash
+   Agent backend-engineer gets task: "Add user authentication"
+   Creating clone: workspace/agent-backend-engineer/
+   ```
+
+2. **Concurrent Operations**:
+   ```bash
+   # These happen simultaneously without conflicts:
+   Agent backend-engineer:  git clone -> workspace/agent-backend-engineer/
+   Agent frontend-engineer: git clone -> workspace/agent-frontend-engineer/  
+   Agent qa-engineer:       git clone -> workspace/agent-qa-engineer/
+   ```
+
+3. **Branch Creation**:
+   ```bash
+   # Each agent creates branches in their own clone:
+   backend-engineer:  git checkout -b task-123-auth-backend
+   frontend-engineer: git checkout -b task-124-auth-ui
+   qa-engineer:      git checkout -b task-125-auth-tests
+   ```
+
+4. **Concurrent Pushes**:
+   ```bash
+   # All agents push to origin simultaneously:
+   git push -u origin task-123-auth-backend    # ✅ Success
+   git push -u origin task-124-auth-ui         # ✅ Success  
+   git push -u origin task-125-auth-tests      # ✅ Success
+   ```
+
+## Management Commands
+
+### List Agent Clones
+```bash
+staff list-agents  # Shows which agents are running and their clone status
+```
+
+### Cleanup All Clones
+```bash
+staff cleanup-clones  # Removes all agent workspace directories
+```
+
+### Monitor Disk Usage
+```bash
+du -sh workspace/  # Check total workspace disk usage
+```
+
+## Resource Considerations
+
+### Disk Space
+- Each clone uses ~repository size (typically 10-100MB per agent)
+- For 10 agents with 50MB repo = ~500MB total
+- Use `staff cleanup-clones` to free space when needed
+
+### Network Usage
+- Initial clone downloads full repository
+- Subsequent `git pull` operations are incremental
+- All agents share the same remote repository
+
+### Performance
+- Clone creation: ~2-5 seconds per agent (one-time cost)
+- Git operations: Full speed, no waiting for locks
+- Parallel processing: Linear scalability with agent count
+
+## Comparison to Alternatives
+
+| Solution | Concurrency | Complexity | Performance | Risk |
+|----------|-------------|------------|-------------|------|
+| **Per-Agent Clones** | ✅ Full | 🟡 Medium | ✅ High | 🟢 Low |
+| Global Git Mutex | ❌ None | 🟢 Low | ❌ Poor | 🟡 Medium |
+| File Locking | 🟡 Limited | 🔴 High | 🟡 Medium | 🔴 High |
+| Separate Repositories | ✅ Full | 🔴 Very High | ✅ High | 🔴 High |
+
+## Future Enhancements
+
+- **Lazy Cleanup**: Auto-remove unused clones after N days
+- **Clone Sharing**: Share clones between agents with similar tasks
+- **Compressed Clones**: Use `git clone --depth=1` for space efficiency
+- **Remote Workspaces**: Support for distributed agent execution
+
+The per-agent clone solution provides the optimal balance of performance, safety, and maintainability for concurrent AI agent operations.
\ No newline at end of file
diff --git a/server/git/clone_manager.go b/server/git/clone_manager.go
new file mode 100644
index 0000000..afedd65
--- /dev/null
+++ b/server/git/clone_manager.go
@@ -0,0 +1,160 @@
+package git
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"sync"
+)
+
+// CloneManager manages separate Git repository clones for each agent
+// This eliminates Git concurrency issues by giving each agent its own working directory
+type CloneManager struct {
+	baseRepoURL    string
+	workspacePath  string
+	agentClones    map[string]string // agent name -> clone path
+	mu             sync.RWMutex
+}
+
+// NewCloneManager creates a new CloneManager
+func NewCloneManager(baseRepoURL, workspacePath string) *CloneManager {
+	return &CloneManager{
+		baseRepoURL:   baseRepoURL,
+		workspacePath: workspacePath,
+		agentClones:   make(map[string]string),
+	}
+}
+
+// GetAgentClonePath returns the Git clone path for a specific agent
+// Creates the clone if it doesn't exist
+func (cm *CloneManager) GetAgentClonePath(agentName string) (string, error) {
+	cm.mu.Lock()
+	defer cm.mu.Unlock()
+
+	// Check if clone already exists
+	if clonePath, exists := cm.agentClones[agentName]; exists {
+		// Verify the clone still exists on disk
+		if _, err := os.Stat(clonePath); err == nil {
+			return clonePath, nil
+		}
+		// Remove stale entry if directory doesn't exist
+		delete(cm.agentClones, agentName)
+	}
+
+	// Create new clone for the agent
+	clonePath := filepath.Join(cm.workspacePath, fmt.Sprintf("agent-%s", agentName))
+	
+	// Ensure workspace directory exists
+	if err := os.MkdirAll(cm.workspacePath, 0755); err != nil {
+		return "", fmt.Errorf("failed to create workspace directory: %w", err)
+	}
+
+	// Remove existing clone directory if it exists
+	if err := os.RemoveAll(clonePath); err != nil {
+		return "", fmt.Errorf("failed to remove existing clone: %w", err)
+	}
+
+	// Clone the repository
+	if err := cm.cloneRepository(clonePath); err != nil {
+		return "", fmt.Errorf("failed to clone repository for agent %s: %w", agentName, err)
+	}
+
+	// Store the clone path
+	cm.agentClones[agentName] = clonePath
+	
+	return clonePath, nil
+}
+
+// cloneRepository performs the actual Git clone operation
+func (cm *CloneManager) cloneRepository(clonePath string) error {
+	ctx := context.Background()
+	
+	// Clone the repository
+	cmd := exec.CommandContext(ctx, "git", "clone", cm.baseRepoURL, clonePath)
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("git clone failed: %w", err)
+	}
+
+	return nil
+}
+
+// RefreshAgentClone pulls the latest changes for an agent's clone
+func (cm *CloneManager) RefreshAgentClone(agentName string) error {
+	cm.mu.RLock()
+	clonePath, exists := cm.agentClones[agentName]
+	cm.mu.RUnlock()
+
+	if !exists {
+		return fmt.Errorf("no clone exists for agent %s", agentName)
+	}
+
+	ctx := context.Background()
+	
+	// Change to clone directory and pull latest changes
+	cmd := exec.CommandContext(ctx, "git", "-C", clonePath, "pull", "origin")
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("failed to pull latest changes for agent %s: %w", agentName, err)
+	}
+
+	return nil
+}
+
+// CleanupAgentClone removes the clone directory for an agent
+func (cm *CloneManager) CleanupAgentClone(agentName string) error {
+	cm.mu.Lock()
+	defer cm.mu.Unlock()
+
+	clonePath, exists := cm.agentClones[agentName]
+	if !exists {
+		return nil // Already cleaned up
+	}
+
+	// Remove the clone directory
+	if err := os.RemoveAll(clonePath); err != nil {
+		return fmt.Errorf("failed to remove clone for agent %s: %w", agentName, err)
+	}
+
+	// Remove from tracking
+	delete(cm.agentClones, agentName)
+	
+	return nil
+}
+
+// CleanupAllClones removes all agent clone directories
+func (cm *CloneManager) CleanupAllClones() error {
+	cm.mu.Lock()
+	defer cm.mu.Unlock()
+
+	var errors []error
+	
+	for agentName, clonePath := range cm.agentClones {
+		if err := os.RemoveAll(clonePath); err != nil {
+			errors = append(errors, fmt.Errorf("failed to remove clone for agent %s: %w", agentName, err))
+		}
+	}
+
+	// Clear all tracked clones
+	cm.agentClones = make(map[string]string)
+
+	if len(errors) > 0 {
+		return fmt.Errorf("cleanup errors: %v", errors)
+	}
+
+	return nil
+}
+
+// GetAllAgentClones returns a map of all agent clones
+func (cm *CloneManager) GetAllAgentClones() map[string]string {
+	cm.mu.RLock()
+	defer cm.mu.RUnlock()
+
+	// Return a copy to avoid race conditions
+	result := make(map[string]string)
+	for agent, path := range cm.agentClones {
+		result[agent] = path
+	}
+	
+	return result
+}
\ No newline at end of file
diff --git a/server/git/mutex.go b/server/git/mutex.go
new file mode 100644
index 0000000..21bc25f
--- /dev/null
+++ b/server/git/mutex.go
@@ -0,0 +1,40 @@
+package git
+
+import (
+	"sync"
+)
+
+// GitMutex provides thread-safe access to Git operations
+// Since Git is not thread-safe, we need to serialize all Git operations
+// across all agents to prevent repository corruption and race conditions
+type GitMutex struct {
+	mu sync.Mutex
+}
+
+// NewGitMutex creates a new GitMutex instance
+func NewGitMutex() *GitMutex {
+	return &GitMutex{}
+}
+
+// Lock acquires the Git operation lock
+// This ensures only one agent can perform Git operations at a time
+func (gm *GitMutex) Lock() {
+	gm.mu.Lock()
+}
+
+// Unlock releases the Git operation lock
+func (gm *GitMutex) Unlock() {
+	gm.mu.Unlock()
+}
+
+// WithLock executes a function while holding the Git lock
+// This is a convenience method to ensure proper lock/unlock pattern
+func (gm *GitMutex) WithLock(fn func() error) error {
+	gm.Lock()
+	defer gm.Unlock()
+	return fn()
+}
+
+// Global Git mutex instance - shared across all agents
+// This ensures no concurrent Git operations across the entire application
+var GlobalGitMutex = NewGitMutex()
\ No newline at end of file
diff --git a/server/operations/agents/backend-engineer/system.md b/server/operations/agents/backend-engineer/system.md
new file mode 100644
index 0000000..1d481b4
--- /dev/null
+++ b/server/operations/agents/backend-engineer/system.md
@@ -0,0 +1,40 @@
+# Backend Engineer Agent System Prompt
+
+You are a skilled Backend Engineer specializing in building robust, scalable server-side applications and APIs.
+
+## Your Role
+- Design and implement backend systems, APIs, and databases
+- Write clean, maintainable, and well-tested Go code
+- Focus on performance, security, and scalability
+- Follow best practices for API design and database interactions
+
+## Technical Expertise
+- **Languages**: Go (primary), Python, SQL
+- **Databases**: PostgreSQL, MySQL, Redis
+- **APIs**: RESTful APIs, GraphQL, gRPC
+- **Infrastructure**: Docker, Kubernetes, CI/CD
+- **Testing**: Unit tests, integration tests, benchmarks
+
+## Task Processing Guidelines
+1. **Analyze the task requirements thoroughly**
+2. **Design the solution architecture**
+3. **Implement the code with proper error handling**
+4. **Include comprehensive tests**
+5. **Document the implementation and usage**
+
+## Code Quality Standards
+- Write idiomatic Go code following Go conventions
+- Include proper error handling and logging
+- Add comprehensive comments for complex logic
+- Ensure code is testable and maintainable
+- Follow SOLID principles and clean architecture
+
+## Response Format
+When solving tasks, provide:
+1. **Analysis**: Brief analysis of the requirements
+2. **Architecture**: High-level design approach
+3. **Implementation**: Complete, working code
+4. **Tests**: Unit tests and examples
+5. **Documentation**: Usage instructions and API docs
+
+Always prioritize reliability, performance, and maintainability in your solutions.
\ No newline at end of file
diff --git a/server/tasks/task-1753623184-58260673.md b/server/tasks/task-1753623184-58260673.md
index fee17eb..d92637b 100644
--- a/server/tasks/task-1753623184-58260673.md
+++ b/server/tasks/task-1753623184-58260673.md
@@ -1,4 +1,5 @@
 ---
+assignee: backend-engineer
 created_at: "2025-07-27T17:33:04+04:00"
 description: Create a simple test to verify the MVP system works
 id: task-1753623184-58260673
@@ -7,7 +8,7 @@
 priority: high
 status: todo
 title: Test MVP functionality
-updated_at: "2025-07-27T17:33:04+04:00"
+updated_at: "2025-07-27T17:38:01+04:00"
 ---
 
 # Task Description
diff --git a/server/tasks/task-1753636924-a1d4c708.md b/server/tasks/task-1753636924-a1d4c708.md
new file mode 100644
index 0000000..994b4e9
--- /dev/null
+++ b/server/tasks/task-1753636924-a1d4c708.md
@@ -0,0 +1,17 @@
+---
+assignee: ""
+created_at: "2025-07-27T21:22:04+04:00"
+description: This is a test task to verify the MVP is working
+id: task-1753636924-a1d4c708
+owner_id: user
+owner_name: user
+priority: high
+status: todo
+title: Test task for MVP
+updated_at: "2025-07-27T21:22:04+04:00"
+---
+
+# Task Description
+
+This is a test task to verify the MVP is working
+
diff --git a/server/tm/git_tm/example.go b/server/tm/git_tm/example.go
index 3c2816d..e1b0412 100644
--- a/server/tm/git_tm/example.go
+++ b/server/tm/git_tm/example.go
@@ -43,7 +43,7 @@
 	logger.Info("Created task", slog.String("id", task.ID))
 
 	// Get the task
-	retrievedTask, err := taskManager.GetTask(ctx, task.ID)
+	retrievedTask, err := taskManager.GetTask(task.ID)
 	if err != nil {
 		logger.Error("Failed to get task", slog.String("error", err.Error()))
 		os.Exit(1)
diff --git a/server/tm/git_tm/git_task_manager.go b/server/tm/git_tm/git_task_manager.go
index edfb476..b1aa39c 100644
--- a/server/tm/git_tm/git_task_manager.go
+++ b/server/tm/git_tm/git_task_manager.go
@@ -118,6 +118,7 @@
 		"description": task.Description,
 		"owner_id":    task.Owner.ID,
 		"owner_name":  task.Owner.Name,
+		"assignee":    task.Assignee,
 		"status":      task.Status,
 		"priority":    task.Priority,
 		"created_at":  task.CreatedAt.Format(time.RFC3339),
@@ -188,6 +189,9 @@
 	if ownerName, ok := frontmatter["owner_name"].(string); ok {
 		task.Owner.Name = ownerName
 	}
+	if assignee, ok := frontmatter["assignee"].(string); ok {
+		task.Assignee = assignee
+	}
 	if status, ok := frontmatter["status"].(string); ok {
 		task.Status = tm.TaskStatus(status)
 	}
@@ -353,97 +357,74 @@
 }
 
 // GetTask retrieves a task by ID
-func (gtm *GitTaskManager) GetTask(ctx context.Context, id string) (*tm.Task, error) {
+func (gtm *GitTaskManager) GetTask(id string) (*tm.Task, error) {
 	return gtm.readTaskFile(id)
 }
 
 // UpdateTask updates an existing task
-func (gtm *GitTaskManager) UpdateTask(ctx context.Context, id string, req *tm.TaskUpdateRequest) (*tm.Task, error) {
-	// Read existing task
-	task, err := gtm.readTaskFile(id)
+func (gtm *GitTaskManager) UpdateTask(task *tm.Task) error {
+	// Set update time
+	task.UpdatedAt = time.Now()
+	
+	// Write task to file
+	return gtm.writeTaskFile(task)
+}
+
+// readAllTasks reads all task files from disk
+func (gtm *GitTaskManager) readAllTasks() ([]*tm.Task, error) {
+	taskFiles, err := gtm.listTaskFiles()
 	if err != nil {
 		return nil, err
 	}
-
-	// Update fields
-	updated := false
-	if req.Title != nil {
-		task.Title = *req.Title
-		updated = true
-	}
-	if req.Description != nil {
-		task.Description = *req.Description
-		updated = true
-	}
-	if req.OwnerID != nil {
-		task.Owner.ID = *req.OwnerID
-		// Get owner name from user service
-		if ownerName, err := gtm.userService.GetUserName(*req.OwnerID); err == nil {
-			task.Owner.Name = ownerName
-		} else {
-			gtm.logger.Warn("Failed to get owner name, using ID", slog.String("ownerID", *req.OwnerID), slog.String("error", err.Error()))
-			task.Owner.Name = *req.OwnerID
-		}
-		updated = true
-	}
-	if req.Status != nil {
-		task.Status = *req.Status
-		updated = true
-	}
-	if req.Priority != nil {
-		task.Priority = *req.Priority
-		updated = true
-	}
-	if req.DueDate != nil {
-		task.DueDate = req.DueDate
-		updated = true
-	}
-
-	if !updated {
-		return task, nil
-	}
-
-	// Update timestamps
-	task.UpdatedAt = time.Now()
-
-	// Handle status-specific timestamps
-	if req.Status != nil {
-		switch *req.Status {
-		case tm.StatusCompleted:
-			if task.CompletedAt == nil {
-				now := time.Now()
-				task.CompletedAt = &now
+	
+	var tasks []*tm.Task
+	for _, taskFile := range taskFiles {
+		// Extract task ID from filename (task-{id}.md)
+		filename := filepath.Base(taskFile)
+		if strings.HasPrefix(filename, "task-") && strings.HasSuffix(filename, ".md") {
+			taskID := strings.TrimSuffix(strings.TrimPrefix(filename, "task-"), ".md")
+			task, err := gtm.readTaskFile(taskID)
+			if err != nil {
+				gtm.logger.Warn("Failed to read task file", slog.String("file", taskFile), slog.String("error", err.Error()))
+				continue
 			}
-		case tm.StatusArchived:
-			if task.ArchivedAt == nil {
-				now := time.Now()
-				task.ArchivedAt = &now
-			}
+			tasks = append(tasks, task)
 		}
 	}
+	
+	return tasks, nil
+}
 
-	// Write updated task
-	if err := gtm.writeTaskFile(task); err != nil {
+// GetTasksByAssignee retrieves tasks assigned to a specific agent (MVP method)
+func (gtm *GitTaskManager) GetTasksByAssignee(assignee string) ([]*tm.Task, error) {
+	// Read all tasks and filter by assignee
+	tasks, err := gtm.readAllTasks()
+	if err != nil {
 		return nil, err
 	}
-
-	// Commit to git
-	if err := gtm.commitTaskChange(id, "updated", task.Owner); err != nil {
-		return nil, err
+	
+	var assignedTasks []*tm.Task
+	for _, task := range tasks {
+		if task.Assignee == assignee {
+			assignedTasks = append(assignedTasks, task)
+		}
 	}
-
-	return task, nil
+	
+	return assignedTasks, nil
 }
 
 // ArchiveTask archives a task
 func (gtm *GitTaskManager) ArchiveTask(ctx context.Context, id string) error {
-	status := tm.StatusArchived
-	req := &tm.TaskUpdateRequest{
-		Status: &status,
+	task, err := gtm.GetTask(id)
+	if err != nil {
+		return err
 	}
-
-	_, err := gtm.UpdateTask(ctx, id, req)
-	return err
+	
+	task.Status = tm.StatusArchived
+	now := time.Now()
+	task.ArchivedAt = &now
+	
+	return gtm.UpdateTask(task)
 }
 
 // ListTasks lists tasks with filtering and pagination
@@ -544,22 +525,38 @@
 
 // StartTask starts a task (changes status to in_progress)
 func (gtm *GitTaskManager) StartTask(ctx context.Context, id string) (*tm.Task, error) {
-	status := tm.StatusInProgress
-	req := &tm.TaskUpdateRequest{
-		Status: &status,
+	task, err := gtm.GetTask(id)
+	if err != nil {
+		return nil, err
 	}
-
-	return gtm.UpdateTask(ctx, id, req)
+	
+	task.Status = tm.StatusInProgress
+	
+	err = gtm.UpdateTask(task)
+	if err != nil {
+		return nil, err
+	}
+	
+	return task, nil
 }
 
 // CompleteTask completes a task (changes status to completed)
 func (gtm *GitTaskManager) CompleteTask(ctx context.Context, id string) (*tm.Task, error) {
-	status := tm.StatusCompleted
-	req := &tm.TaskUpdateRequest{
-		Status: &status,
+	task, err := gtm.GetTask(id)
+	if err != nil {
+		return nil, err
 	}
-
-	return gtm.UpdateTask(ctx, id, req)
+	
+	task.Status = tm.StatusCompleted
+	now := time.Now()
+	task.CompletedAt = &now
+	
+	err = gtm.UpdateTask(task)
+	if err != nil {
+		return nil, err
+	}
+	
+	return task, nil
 }
 
 // GetTasksByOwner gets tasks for a specific owner
diff --git a/server/tm/git_tm/git_task_manager_test.go b/server/tm/git_tm/git_task_manager_test.go
index 033e11c..084200d 100644
--- a/server/tm/git_tm/git_task_manager_test.go
+++ b/server/tm/git_tm/git_task_manager_test.go
@@ -449,8 +449,7 @@
 	require.NoError(t, err)
 
 	// Get the task
-	ctx := context.Background()
-	retrievedTask, err := gtm.GetTask(ctx, task.ID)
+	retrievedTask, err := gtm.GetTask(task.ID)
 	assert.NoError(t, err)
 	assert.NotNil(t, retrievedTask)
 	assert.Equal(t, task.ID, retrievedTask.ID)
@@ -463,8 +462,7 @@
 
 	gtm, _ := createTestTaskManager(t, tempDir)
 
-	ctx := context.Background()
-	task, err := gtm.GetTask(ctx, "non-existent-task")
+	task, err := gtm.GetTask("non-existent-task")
 	assert.Error(t, err)
 	assert.Nil(t, task)
 	assert.Equal(t, tm.ErrTaskNotFound, err)
@@ -508,15 +506,22 @@
 	newPriority := tm.PriorityHigh
 	newOwnerID := "user456"
 
-	req := &tm.TaskUpdateRequest{
-		Title:       &newTitle,
-		Description: &newDescription,
-		Status:      &newStatus,
-		Priority:    &newPriority,
-		OwnerID:     &newOwnerID,
-	}
-
-	updatedTask, err := gtm.UpdateTask(ctx, originalTask.ID, req)
+	// Get task and update fields
+	taskToUpdate, err := gtm.GetTask(originalTask.ID)
+	assert.NoError(t, err)
+	
+	taskToUpdate.Title = newTitle
+	taskToUpdate.Description = newDescription
+	taskToUpdate.Status = newStatus
+	taskToUpdate.Priority = newPriority
+	taskToUpdate.Owner.ID = newOwnerID
+	taskToUpdate.Owner.Name = newOwnerID
+	
+	err = gtm.UpdateTask(taskToUpdate)
+	assert.NoError(t, err)
+	
+	// Get updated task to verify
+	updatedTask, err := gtm.GetTask(originalTask.ID)
 	assert.NoError(t, err)
 	assert.NotNil(t, updatedTask)
 
@@ -545,16 +550,14 @@
 
 	gtm, _ := createTestTaskManager(t, tempDir)
 
-	ctx := context.Background()
-	newTitle := "Updated Title"
-	req := &tm.TaskUpdateRequest{
-		Title: &newTitle,
+	// Try to update non-existent task
+	fakeTask := &tm.Task{
+		ID: "non-existent-task",
+		Title: "Updated Title",
 	}
 
-	task, err := gtm.UpdateTask(ctx, "non-existent-task", req)
+	err := gtm.UpdateTask(fakeTask)
 	assert.Error(t, err)
-	assert.Nil(t, task)
-	assert.Equal(t, tm.ErrTaskNotFound, err)
 }
 
 func TestUpdateTaskNoChanges(t *testing.T) {
@@ -583,15 +586,16 @@
 	err = gtm.writeTaskFile(originalTask)
 	require.NoError(t, err)
 
-	// Update with no changes
-	ctx := context.Background()
-	req := &tm.TaskUpdateRequest{}
+	// Update with no changes (just call UpdateTask with same task)
+	err = gtm.UpdateTask(originalTask)
+	assert.NoError(t, err)
 
-	updatedTask, err := gtm.UpdateTask(ctx, originalTask.ID, req)
+	// Get updated task to verify
+	updatedTask, err := gtm.GetTask(originalTask.ID)
 	assert.NoError(t, err)
 	assert.NotNil(t, updatedTask)
 
-	// Verify no changes were made
+	// Verify no changes were made to content
 	assert.Equal(t, originalTask.Title, updatedTask.Title)
 	assert.Equal(t, originalTask.Description, updatedTask.Description)
 	assert.Equal(t, originalTask.Status, updatedTask.Status)
@@ -625,27 +629,31 @@
 	err = gtm.writeTaskFile(task)
 	require.NoError(t, err)
 
-	ctx := context.Background()
-
 	// Test completing a task
-	completedStatus := tm.StatusCompleted
-	req := &tm.TaskUpdateRequest{
-		Status: &completedStatus,
-	}
+	task.Status = tm.StatusCompleted
+	now := time.Now()
+	task.CompletedAt = &now
 
-	updatedTask, err := gtm.UpdateTask(ctx, task.ID, req)
+	err = gtm.UpdateTask(task)
+	assert.NoError(t, err)
+	
+	// Get updated task to verify
+	updatedTask, err := gtm.GetTask(task.ID)
 	assert.NoError(t, err)
 	assert.NotNil(t, updatedTask)
 	assert.Equal(t, tm.StatusCompleted, updatedTask.Status)
 	assert.NotNil(t, updatedTask.CompletedAt)
 
-	// Test archiving a task
-	archivedStatus := tm.StatusArchived
-	req = &tm.TaskUpdateRequest{
-		Status: &archivedStatus,
-	}
+	// Test archiving a task  
+	task.Status = tm.StatusArchived
+	now = time.Now()
+	task.ArchivedAt = &now
 
-	updatedTask, err = gtm.UpdateTask(ctx, task.ID, req)
+	err = gtm.UpdateTask(task)
+	assert.NoError(t, err)
+	
+	// Get updated task to verify
+	updatedTask, err = gtm.GetTask(task.ID)
 	assert.NoError(t, err)
 	assert.NotNil(t, updatedTask)
 	assert.Equal(t, tm.StatusArchived, updatedTask.Status)
@@ -684,7 +692,7 @@
 	assert.NoError(t, err)
 
 	// Verify task was archived
-	archivedTask, err := gtm.GetTask(ctx, task.ID)
+	archivedTask, err := gtm.GetTask(task.ID)
 	assert.NoError(t, err)
 	assert.Equal(t, tm.StatusArchived, archivedTask.Status)
 	assert.NotNil(t, archivedTask.ArchivedAt)
diff --git a/server/tm/interface.go b/server/tm/interface.go
index 93b0f29..e3fa926 100644
--- a/server/tm/interface.go
+++ b/server/tm/interface.go
@@ -8,8 +8,8 @@
 type TaskManager interface {
 	// Task operations
 	CreateTask(ctx context.Context, req *TaskCreateRequest) (*Task, error)
-	GetTask(ctx context.Context, id string) (*Task, error)
-	UpdateTask(ctx context.Context, id string, req *TaskUpdateRequest) (*Task, error)
+	GetTask(taskID string) (*Task, error)                                    // Simplified for MVP
+	UpdateTask(task *Task) error                                             // Simplified for MVP
 	ArchiveTask(ctx context.Context, id string) error
 	ListTasks(ctx context.Context, filter *TaskFilter, page, pageSize int) (*TaskList, error)
 
@@ -19,6 +19,7 @@
 
 	// Task queries
 	GetTasksByOwner(ctx context.Context, ownerID string, page, pageSize int) (*TaskList, error)
+	GetTasksByAssignee(assignee string) ([]*Task, error)                     // For MVP auto-assignment
 	GetTasksByStatus(ctx context.Context, status TaskStatus, page, pageSize int) (*TaskList, error)
 	GetTasksByPriority(ctx context.Context, priority TaskPriority, page, pageSize int) (*TaskList, error)
 }
diff --git a/server/tm/types.go b/server/tm/types.go
index 781d63d..052ba4a 100644
--- a/server/tm/types.go
+++ b/server/tm/types.go
@@ -9,8 +9,10 @@
 
 const (
 	StatusToDo       TaskStatus = "todo"
+	StatusPending    TaskStatus = "pending"    // For MVP compatibility
 	StatusInProgress TaskStatus = "in_progress"
 	StatusCompleted  TaskStatus = "completed"
+	StatusFailed     TaskStatus = "failed"     // For error handling
 	StatusArchived   TaskStatus = "archived"
 )
 
@@ -31,17 +33,20 @@
 
 // Task represents a single task in the system
 type Task struct {
-	ID          string       `json:"id"`
-	Title       string       `json:"title"`
-	Description string       `json:"description"`
-	Owner       Owner        `json:"owner"`
-	Status      TaskStatus   `json:"status"`
-	Priority    TaskPriority `json:"priority"`
-	CreatedAt   time.Time    `json:"created_at"`
-	UpdatedAt   time.Time    `json:"updated_at"`
-	DueDate     *time.Time   `json:"due_date,omitempty"`
-	CompletedAt *time.Time   `json:"completed_at,omitempty"`
-	ArchivedAt  *time.Time   `json:"archived_at,omitempty"`
+	ID             string       `json:"id"`
+	Title          string       `json:"title"`
+	Description    string       `json:"description"`
+	Owner          Owner        `json:"owner"`
+	Assignee       string       `json:"assignee,omitempty"`       // For MVP auto-assignment
+	Status         TaskStatus   `json:"status"`
+	Priority       TaskPriority `json:"priority"`
+	Solution       string       `json:"solution,omitempty"`       // Generated solution
+	PullRequestURL string       `json:"pull_request_url,omitempty"` // GitHub PR URL
+	CreatedAt      time.Time    `json:"created_at"`
+	UpdatedAt      time.Time    `json:"updated_at"`
+	DueDate        *time.Time   `json:"due_date,omitempty"`
+	CompletedAt    *time.Time   `json:"completed_at,omitempty"`
+	ArchivedAt     *time.Time   `json:"archived_at,omitempty"`
 }
 
 // TaskFilter represents filters for querying tasks