> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mixus.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Multi-User Verification Flows

> Set up distributed human oversight with different stakeholders approving specific parts of agent workflows

## Core Concept

Multi-user verification enables different stakeholders to approve specific parts of a workflow without seeing or being overwhelmed by the entire process. This creates clear accountability, reduces cognitive load, and ensures the right expert reviews the right decisions.

## How Multi-User Verification Works

### Technical Architecture

1. **User Assignment**: Each agent or step can be assigned to specific users or roles
2. **Notification System**: When verification is needed, the assigned user receives a notification
3. **Isolated Context**: Reviewers only see the relevant step output, not the entire chain
4. **Approval Actions**: Approve, Reject, or Modify with comments
5. **Audit Trail**: All decisions are logged with timestamp and user ID

```typescript theme={null}
// Agent configuration with verification
{
  name: "purchase-order-processor",
  steps: [
    {
      description: "Validate vendor and calculate total",
      requiresVerification: false
    },
    {
      description: "Approve purchase if over $10,000",
      requiresVerification: true,
      verificationConfig: {
        assignedTo: "finance-manager@company.com",
        escalationAfter: "2 hours",
        escalateTo: "cfo@company.com"
      }
    }
  ]
}
```

## Verification Assignment Patterns

### Pattern 1: Role-Based Assignment

```yaml theme={null}
Contract-Review-Chain:

  Legal-Review-Agent:
    Step 2: "Review terms and conditions"
    Verify By: @legal-team

  Finance-Review-Agent:
    Step 2: "Validate payment terms"
    Verify By: @finance-team

  Executive-Approval-Agent:
    Step 1: "Final contract approval"
    Verify By: @c-suite
```

### Pattern 2: Expertise-Based Routing

```yaml theme={null}
Technical-Document-Processor:

  Step 1: "Extract technical specifications"
  Verify By: (Automatic based on content)
    - If contains "API": @backend-team
    - If contains "UI/UX": @design-team
    - If contains "Infrastructure": @devops-team
```

### Pattern 3: Hierarchical Escalation

```yaml theme={null}
Expense-Approval-Agent:

  Step: "Approve expense report"
  Verification Logic:
    - Amount < $500: @direct-manager
    - Amount $500-$5000: @department-head
    - Amount > $5000: @finance-director
    - Amount > $25000: @cfo
```

## Real-World Multi-User Verification Scenarios

### Scenario 1: Marketing Campaign Launch

```yaml theme={null}
Campaign-Creative-Agent:
  Owner: Sarah (Creative Director)
  Steps:
    1. Generate campaign visuals
    2. Review brand compliance ✓ [Requires: Sarah]
    3. Run 'copy-writer-agent'

Copy-Writer-Agent:
  Owner: Mike (Head of Copy)
  Steps:
    1. Create campaign messaging
    2. Verify tone and accuracy ✓ [Requires: Mike]
    3. Run 'legal-review-agent'

Legal-Review-Agent:
  Owner: Lisa (Legal Counsel)
  Steps:
    1. Check compliance and disclaimers
    2. Approve legal language ✓ [Requires: Lisa]
    3. Run 'campaign-launcher-agent'

Campaign-Launcher-Agent:
  Owner: Tom (Marketing Director)
  Steps:
    1. Schedule across channels
    2. Final approval to go live ✓ [Requires: Tom]
    3. Launch campaign
```

Benefits:

* Sarah only reviews visuals, not legal text
* Mike focuses on messaging quality
* Lisa ensures compliance without creative concerns
* Tom has final say on timing and strategy

### Scenario 2: Employee Onboarding Pipeline

```yaml theme={null}
Background-Check-Agent:
  Verify By: HR-Specialist
  Steps: 1. Run background verification
    2. Review red flags ✓
    3. Run 'it-provisioning-agent'

IT-Provisioning-Agent:
  Verify By: IT-Manager
  Steps: 1. Create accounts and access
    2. Confirm security clearance ✓
    3. Run 'workspace-setup-agent'

Workspace-Setup-Agent:
  Verify By: Facilities-Manager
  Steps: 1. Assign desk and equipment
    2. Verify setup completion ✓
    3. Run 'buddy-assignment-agent'

Buddy-Assignment-Agent:
  Verify By: Team-Lead
  Steps: 1. Match with team buddy
    2. Confirm buddy availability ✓
    3. Send welcome package
```

### Scenario 3: Loan Application Processing

```yaml theme={null}
Application-Validator:
  Steps: 1. Verify applicant information
    2. Run 'credit-analyzer'

Credit-Analyzer:
  Verify By: Credit-Analyst
  Steps: 1. Pull credit reports
    2. Assess credit risk ✓ [If score < 650]
    3. Run 'income-verifier'

Income-Verifier:
  Verify By: Underwriter
  Steps: 1. Validate income documents
    2. Calculate debt-to-income ✓
    3. Run 'risk-assessor'

Risk-Assessor:
  Verify By: Senior-Underwriter
  Steps: 1. Comprehensive risk analysis
    2. Set loan terms ✓ [If amount > $500K]
    3. Run 'approval-generator'

Approval-Generator:
  Verify By: Loan-Officer
  Steps: 1. Generate approval letter
    2. Final approval ✓
    3. Send to customer
```

## Implementing Verification Workflows

### 1. Notification Systems

```typescript theme={null}
// When verification is required
{
  notificationType: "email" | "slack" | "in-app",
  recipient: "assigned-user@company.com",
  subject: "Verification Required: {agent-name}",
  body: {
    agentName: "expense-processor",
    stepDescription: "Approve expense over $5000",
    outputPreview: "Total: $7,845 for client dinner",
    actionLink: "https://app.mixus.ai/verify/{verification-id}"
  },
  urgency: "high",
  deadline: "2 hours"
}
```

### 2. Verification Interface

```text theme={null}
┌─────────────────────────────────────────────┐
│ Verification Required                        │
│                                             │
│ Agent: contract-reviewer                     │
│ Step: Approve vendor terms                   │
│                                             │
│ Output Summary:                             │
│ • Vendor: Acme Corp                         │
│ • Contract Value: $125,000                  │
│ • Payment Terms: Net 30                     │
│ • Key Risks:                                │
│   - No liability cap                        │
│   - Auto-renewal clause                     │
│                                             │
│ Your Decision:                              │
│ ○ Approve as-is                            │
│ ○ Approve with modifications               │
│ ○ Reject                                   │
│                                             │
│ Comments: [___________________________]     │
│                                             │
│ [Submit Decision]  [Request More Info]      │
└─────────────────────────────────────────────┘
```

### 3. Verification Context Isolation

```yaml theme={null}
What Reviewers See: ✓ Current step output
  ✓ Specific data they need to verify
  ✓ Decision criteria
  ✓ Escalation options

What Reviewers DON'T See: ✗ Previous agent outputs (unless relevant)
  ✗ Downstream agent plans
  ✗ Other users' verification decisions
  ✗ Unrelated workflow branches
```

## Advanced Verification Patterns

### Parallel Verification

```yaml theme={null}
Proposal-Reviewer:
  Step 2: 'Review proposal sections'
  Parallel Verification:
    - Technical section → CTO
    - Budget section → CFO
    - Timeline section → PMO
  Continue When: All approved
```

### Conditional Verification

```yaml theme={null}
Payment-Processor:
  Step 2: "Process payment"
  Verification Rules:
    - If international && amount > $10K: @compliance-team
    - If high-risk-country: @fraud-team
    - If existing-customer && amount < $1K: No verification
    - Else: @finance-team
```

### Delegation Chains

```yaml theme={null}
Document-Approver:
  Primary Verifier: @department-head
  Delegation Rules:
    - If out-of-office: @deputy-head
    - If escalation-timeout (4h): @division-director
    - If urgent-flag: @emergency-approver
```

## Verification Analytics and Optimization

### Tracking Verification Metrics

```yaml theme={null}
Verification-Analytics-Agent:
  Schedule: Weekly
  Steps:
    1. Search: "verification required approved rejected"
    2. Calculate:
       - Average time to verify per role
       - Rejection rates by agent
       - Escalation frequency
       - Bottleneck identification
    3. Generate optimization report
```

### Sample Metrics Dashboard

```text theme={null}
Verification Performance (Last 30 Days)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Average Response Times:
• Finance Team: 1.2 hours
• Legal Team: 3.4 hours
• Sales Managers: 45 minutes

Approval Rates:
• Overall: 87%
• After modifications: 96%

Top Bottlenecks:
1. Legal review for contracts > $100K
2. Executive approval for budgets
3. Compliance check for international

Optimization Opportunities:
• Pre-filter legal reviews with AI
• Batch similar approvals
• Implement auto-escalation rules
```

## Best Practices for Multi-User Verification

### 1. Clear Decision Criteria

```yaml theme={null}
Good Verification Step:
  Description: 'Approve discount if:'
  Criteria:
    - Discount <= 20% for orders > $10K
    - Customer loyalty score > 80
    - No previous payment issues
  Output Format: Structured discount details

Poor Verification Step:
  Description: 'Review and approve if looks good'
  Criteria: None specified
  Output Format: Unstructured text
```

### 2. Minimize Context Switching

```yaml theme={null}
Batch Similar Verifications:
  Instead of:
    - Contract 1 → Legal review
    - Invoice 1 → Finance review
    - Contract 2 → Legal review
    - Invoice 2 → Finance review

  Optimize to:
    - Contract 1 & 2 → Legal batch review
    - Invoice 1 & 2 → Finance batch review
```

### 3. Smart Routing

```typescript theme={null}
// Dynamic verifier assignment
function assignVerifier(context) {
  if (context.region === 'EU' && context.type === 'data-processing') {
    return 'gdpr-specialist@company.com'
  } else if (context.amount > context.user.approvalLimit) {
    return context.user.manager
  } else {
    return context.defaultApprover
  }
}
```

### 4. Verification Templates

```yaml theme={null}
Reusable Verification Patterns:

Financial-Approval-Template:
  Thresholds: [1000, 5000, 25000, 100000]
  Approvers: [manager, director, vp, cfo]

Risk-Assessment-Template:
  Levels: [low, medium, high, critical]
  Reviewers: [analyst, senior-analyst, manager, chief-risk-officer]

Compliance-Check-Template:
  Regions: [US, EU, APAC, LATAM]
  Specialists: [us-compliance, gdpr-team, apac-legal, latam-regulatory]
```

## Security and Compliance Considerations

### Access Control

```yaml theme={null}
Verification-Access-Rules:
  - Verifiers can only see assigned steps
  - No access to modify agent logic
  - Cannot see other users' decisions before submitting
  - Audit log access restricted to compliance team
```

### Audit Requirements

```typescript theme={null}
// Every verification creates an audit record
{
  verificationId: "uuid",
  agentName: "contract-processor",
  stepNumber: 2,
  assignedTo: "legal@company.com",
  verifiedBy: "legal@company.com",
  decision: "approved_with_modifications",
  modifications: {...},
  timestamp: "2024-01-15T10:30:00Z",
  ipAddress: "192.168.1.100",
  sessionId: "session-uuid"
}
```

### Compliance Patterns

```yaml theme={null}
SOX-Compliance-Pattern:
  - Segregation of duties enforced
  - No self-approval allowed
  - All financial decisions logged
  - Quarterly audit reports generated

GDPR-Compliance-Pattern:
  - Data minimization in verification views
  - Right to explanation for automated decisions
  - Verification decisions are themselves auditable
  - PII masked unless necessary for decision
```

## Related Documentation

* [Micro-Agent Concepts](micro-agent-concepts) - Core architecture and chaining patterns
* [Context Management](micro-agent-context-verification) - How context flows between agents
* [KPI Monitoring](micro-agent-kpi-monitoring) - Performance tracking with search-chat-history
* [Advanced Use Cases](micro-agent-use-cases-tips) - Creative applications and optimization tips

***

*Need help setting up multi-user verification? Check our [agent creation guide](/agents/creating) or contact [support](/support/contact).*