---

title: "Human-AI Collaboration Patterns" description: "Research on integrating human judgment, approval workflows, and feedback in agentic systems" date: 2026-02-06 topics: [human-ai-collaboration, workflows, approval, feedback] sources: 0 status: initial

Human-AI Collaboration Patterns

Overview

Effective agentic systems require thoughtful integration of human judgment at critical points. This research covers patterns for human-AI collaboration, approval workflows, and seamless handoffs between automated and human-driven processes.

Collaboration Models

1. Human-in-the-Loop (HITL)

Active Oversight

typescript
interface HumanInTheLoop {
  // Human reviews before action
  async requestApproval(
    action: ProposedAction,
    context: Context
  ): Promise<Decision> {
    // Present to human
    const presentation = this.formatForHuman(action, context);
    
    // Wait for response
    const decision = await this.waitForHumanDecision(presentation);
    
    // Record feedback
    await this.recordInteraction(action, decision);
    
    return decision;
  }
}

Trigger Conditions

typescript
interface ApprovalTriggers {
  // Financial impact
  costThreshold: number;        // > $X requires approval
  
  // Risk level
  riskScore: number;            // Risk > threshold
  
  // Irreversibility
  irreversibleActions: string[]; // Delete, deploy prod, etc.
  
  // Novelty
  novelPattern: boolean;        // Never seen this before
  
  // Confidence
  lowConfidence: boolean;       // AI confidence < threshold
}

2. Human-on-the-Loop (HOTL)

Passive Monitoring with Override

typescript
interface HumanOnTheLoop {
  async executeWithMonitoring(
    action: Action
  ): Promise<Result> {
    // Start execution
    const execution = this.startExecution(action);
    
    // Notify human (non-blocking)
    this.notifyHuman(action, 'started');
    
    // Monitor for override
    const overridePromise = this.watchForOverride(action.id);
    const resultPromise = execution.waitForCompletion();
    
    // Race between completion and override
    const result = await Promise.race([
      resultPromise,
      overridePromise.then(() => this.cancel(execution))
    ]);
    
    return result;
  }
}

3. Human-out-of-the-Loop (HOOTL)

Full Autonomy with Logging

typescript
interface HumanOutOfTheLoop {
  async executeAutonomously(
    action: Action
  ): Promise<Result> {
    // Execute without human involvement
    const result = await this.execute(action);
    
    // Log for post-hoc review
    await this.logForAudit({
      action,
      result,
      timestamp: new Date(),
      reasoning: this.explainDecision(action)
    });
    
    // Periodic batch review
    return result;
  }
}

Approval Workflows

1. Single Approver

typescript
interface SingleApprover {
  approver: User;
  
  async requestApproval(request: Request): Promise<Decision> {
    // Send to designated approver
    const notification = await this.notify(this.approver, request);
    
    // Wait with timeout
    const decision = await this.waitForResponse(
      notification,
      timeout: 24 * 60 * 60 * 1000 // 24 hours
    );
    
    if (decision.timedOut) {
      // Escalate
      return this.escalate(request);
    }
    
    return decision;
  }
}

2. Multi-Level Approval

typescript
interface MultiLevelApproval {
  levels: ApprovalLevel[];
  
  async requestMultiLevelApproval(
    request: Request
  ): Promise<Decision> {
    let currentRequest = request;
    
    for (const level of this.levels) {
      const decision = await level.approve(currentRequest);
      
      if (!decision.approved) {
        return { approved: false, atLevel: level.name };
      }
      
      // Add approval context to request
      currentRequest = {
        ...currentRequest,
        approvals: [...currentRequest.approvals, decision]
      };
    }
    
    return { approved: true };
  }
}

interface ApprovalLevel {
  name: string;
  approvers: User[];
  threshold: number; // How many approvals needed
  condition: (request: Request) => boolean; // When this level applies
}

3. Consensus-Based Approval

typescript
interface ConsensusApproval {
  async requestConsensus(
    request: Request,
    reviewers: User[]
  ): Promise<Decision> {
    // Request review from all
    const reviews = await Promise.all(
      reviewers.map(r => this.requestReview(r, request))
    );
    
    // Analyze consensus
    const approveCount = reviews.filter(r => r.approved).length;
    const rejectCount = reviews.filter(r => !r.approved).length;
    
    if (approveCount / reviewers.length >= 0.6) {
      return { approved: true, reviews };
    } else if (rejectCount / reviewers.length >= 0.4) {
      return { approved: false, reviews };
    } else {
      // No clear consensus - require discussion
      return this.scheduleDiscussion(request, reviews);
    }
  }
}

Collaboration Interfaces

1. Structured Requests

typescript
interface StructuredRequest {
  // What is being requested
  action: {
    type: string;
    description: string;
    parameters: Record<string, any>;
  };
  
  // Why it's being requested
  rationale: {
    goal: string;
    context: string;
    alternatives: string[];
    expectedOutcome: string;
  };
  
  // Impact assessment
  impact: {
    risk: RiskAssessment;
    cost: CostEstimate;
    scope: string[];
  };
  
  // AI's recommendation
  recommendation: {
    suggested: boolean;
    confidence: number;
    reasoning: string;
  };
}

2. Rich Context Presentation

typescript
interface ContextPresentation {
  // Summary for quick review
  executiveSummary: string;
  
  // Detailed information for deep dive
  details: {
    codeDiff?: CodeDiff;
    architecture?: ArchitectureDiagram;
    testResults?: TestReport;
    securityScan?: SecurityReport;
  };
  
  // Comparable examples
  similarCases: CaseStudy[];
  
  // Historical context
  precedents: Decision[];
}

3. Feedback Collection

typescript
interface FeedbackCollection {
  async collectFeedback(
    action: Action,
    outcome: Outcome
  ): Promise<Feedback> {
    // Did it work as expected?
    const outcomeFeedback = await this.askOutcomeFeedback(outcome);
    
    // Was the decision correct?
    const decisionFeedback = await this.askDecisionFeedback(action);
    
    // What would you do differently?
    const improvementSuggestions = await this.askImprovements();
    
    return {
      outcome: outcomeFeedback,
      decision: decisionFeedback,
      improvements: improvementSuggestions,
      timestamp: new Date()
    };
  }
}

Escalation Patterns

1. Time-Based Escalation

typescript
interface TimeBasedEscalation {
  async escalateIfTimeout(
    request: Request,
    timeout: number
  ): Promise<Decision> {
    try {
      const decision = await this.waitForApproval(request, timeout);
      return decision;
    } catch (timeout) {
      // Escalate to next level
      const escalatedRequest = {
        ...request,
        escalationReason: 'timeout',
        originalTimeout: timeout
      };
      
      return this.escalate(escalatedRequest);
    }
  }
}

2. Complexity-Based Escalation

typescript
interface ComplexityEscalation {
  async evaluateAndEscalate(request: Request): Promise<Decision> {
    const complexity = this.assessComplexity(request);
    
    if (complexity > this.currentLevel.maxComplexity) {
      return this.escalateToHigherLevel(request, complexity);
    }
    
    return this.processAtCurrentLevel(request);
  }
}

3. Disagreement Escalation

typescript
interface DisagreementEscalation {
  async handleDisagreement(
    request: Request,
    conflictingDecisions: Decision[]
  ): Promise<Decision> {
    // If reviewers disagree, escalate
    if (this.hasSignificantDisagreement(conflictingDecisions)) {
      return this.escalate({
        ...request,
        conflictingDecisions,
        escalationReason: 'disagreement'
      });
    }
    
    // Otherwise, majority rules
    return this.majorityDecision(conflictingDecisions);
  }
}

Adaptive Collaboration

1. Learning When to Escalate

typescript
interface AdaptiveEscalation {
  async shouldEscalate(request: Request): Promise<boolean> {
    // Check hard rules first
    if (this.matchesHardRule(request)) {
      return true;
    }
    
    // Use learned model
    const features = this.extractFeatures(request);
    const escalationProbability = await this.model.predict(features);
    
    // Consider past outcomes
    const similarRequests = await this.findSimilar(request);
    const outcomeRate = this.calculateSuccessRate(similarRequests);
    
    // Escalate if uncertain or historically problematic
    return escalationProbability > 0.7 || outcomeRate < 0.8;
  }
}

2. Personalized Collaboration

typescript
interface PersonalizedCollaboration {
  async personalizeForUser(
    user: User,
    request: Request
  ): Promise<Presentation> {
    // Load user preferences
    const preferences = await this.getUserPreferences(user);
    
    // Adapt detail level
    const detailLevel = preferences.detailPreference;
    
    // Adapt notification method
    const notificationMethod = preferences.notificationPreference;
    
    // Adapt explanation style
    const explanationStyle = preferences.explanationStyle;
    
    return this.formatRequest(request, {
      detailLevel,
      notificationMethod,
      explanationStyle
    });
  }
}

Observability

1. Collaboration Metrics

typescript
interface CollaborationMetrics {
  // Responsiveness
  averageResponseTime: number;
  responseTimeDistribution: Histogram;
  
  // Decision patterns
  approvalRate: number;
  escalationRate: number;
  overrideRate: number;
  
  // Quality
  decisionAccuracy: number;       // Decisions that led to good outcomes
  falsePositiveRate: number;      // Unnecessary escalations
  falseNegativeRate: number;      // Missed escalations
  
  // Satisfaction
  humanSatisfaction: number;
  aiEffectiveness: number;
}

2. Audit Trail

typescript
interface CollaborationAudit {
  requestId: string;
  timestamp: Date;
  requestor: 'ai' | 'human';
  approvers: User[];
  decisions: Decision[];
  feedback: Feedback[];
  outcomes: Outcome[];
}

Open Questions

• What's the optimal human-AI task split?
• How to prevent alert fatigue in humans?
• When should AI override human decisions?
• How to measure collaboration effectiveness?
• What's the right granularity of human control?