{decidedTools} of {totalTools} tools decided {isComplete && ' • Ready to submit'}

); } ``` ### Approval Action Patterns **Individual Tool Actions**: For APPROVED and DENIED states ```typescript function ToolActions({ tool, onDecision }: ToolActionsProps) { return (

); } ``` **Batch-Level Actions**: For convenience and abort scenarios ```typescript function BatchActions({ batchId, tools }: BatchActionsProps) { const [showFeedbackInput, setShowFeedbackInput] = useState(false); return (

{/* Quick actions for approve/deny all */} {/* Feedback input for abort */} {showFeedbackInput ? ( abortBatchWithFeedback(batchId, tools, feedback)} onCancel={() => setShowFeedbackInput(false)} /> ) : ( )}

); } ``` ## State Management Strategies ### Centralized Batch Manager ```typescript class ApprovalStateManager { private batches = new Map(); private listeners = new Set(); addApprovalRequest(request: ToolApprovalRequest) { const batchId = request.toolExecutionBatchId; if (!this.batches.has(batchId)) { this.batches.set(batchId, { batchId, tools: [], decisions: new Map(), isComplete: false, canSubmit: false, submittedAt: null }); } this.batches.get(batchId)!.tools.push(request); this.notifyListeners(); } setDecision(toolExecutionId: string, decision: ApprovalDecision) { for (const batch of this.batches.values()) { const tool = batch.tools.find(t => t.toolExecutionId === toolExecutionId); if (tool) { batch.decisions.set(toolExecutionId, decision); this.updateBatchState(batch); this.notifyListeners(); break; } } } private updateBatchState(batch: BatchState) { const totalTools = batch.tools.length; const decidedTools = batch.decisions.size; batch.isComplete = decidedTools === totalTools; batch.canSubmit = batch.isComplete && this.validateBatchDecisions(batch); } private validateBatchDecisions(batch: BatchState): boolean { const decisions = Array.from(batch.decisions.values()); const hasAbort = decisions.includes('ABORTED'); const hasOtherStates = decisions.some(d => d !== 'ABORTED'); // Invalid: mixed abort with other states if (hasAbort && hasOtherStates) { return false; } return true; } async submitBatch(batchId: string, feedback?: string) { const batch = this.batches.get(batchId); if (!batch || !batch.canSubmit) { throw new Error(`Batch ${batchId} is not ready for submission`); } try { await this.apiSubmitter.submitBatch(batch, feedback); batch.submittedAt = new Date(); this.notifyListeners(); } catch (error) { console.error('Batch submission failed:', error); throw error; } } } ``` ### React Hook Integration ```typescript function useApprovalBatch(batchId: string) { const [batch, setBatch] = useState(null); useEffect(() => { const listener = (updatedBatch: BatchState) => { if (updatedBatch.batchId === batchId) { setBatch({ ...updatedBatch }); } }; ApprovalStateManager.addListener(listener); setBatch(ApprovalStateManager.getBatch(batchId)); return () => ApprovalStateManager.removeListener(listener); }, [batchId]); const setDecision = useCallback((toolId: string, decision: ApprovalDecision) => { ApprovalStateManager.setDecision(toolId, decision); }, []); const submitBatch = useCallback((feedback?: string) => { return ApprovalStateManager.submitBatch(batchId, feedback); }, [batchId]); return { batch, setDecision, submitBatch }; } ``` ## Feedback Collection Patterns ### Contextual Feedback Input ```typescript function FeedbackInput({ tool, onSubmit, placeholder = "Why are you stopping this action?" }: FeedbackInputProps) { const [feedback, setFeedback] = useState(''); const [isSubmitting, setIsSubmitting] = useState(false); const handleSubmit = async () => { if (!feedback.trim()) { toast.error('Please provide feedback before aborting'); return; } setIsSubmitting(true); try { await onSubmit(feedback); } catch (error) { toast.error('Failed to submit feedback'); } finally { setIsSubmitting(false); } }; return (

Stopping: {tool.toolName}

This will abort all tools in the current batch.

setFeedback(e.target.value)}
        placeholder={placeholder}
        className="feedback-textarea"
        rows={3}
      />
      
      <div className="feedback-actions">
        <button 
          onClick={handleSubmit}
          disabled={!feedback.trim() || isSubmitting}
          className="submit-feedback"
        >
          {isSubmitting ? 'Submitting...' : 'Submit Feedback & Stop'}
        </button>
        <button onClick={onCancel} className="cancel-feedback">
          Cancel
        </button>
      </div>
    </div>
  );
}
```

### Feedback Templates

Provide common feedback templates to help users:

```typescript
const FEEDBACK_TEMPLATES = [
  {
    category: 'Incorrect Parameters',
    templates: [
      'The email recipient list is incorrect',
      'The calendar time is wrong',
      'The file path doesn\'t exist'
    ]
  },
  {
    category: 'Safety Concerns', 
    templates: [
      'This action could delete important data',
      'External recipients should not receive this',
      'This requires additional approval'
    ]
  },
  {
    category: 'Misunderstanding',
    templates: [
      'The agent misunderstood my request',
      'This is not what I wanted to accomplish',
      'Please clarify the requirements first'
    ]
  }
];

function FeedbackTemplates({ onSelect }: { onSelect: (text: string) => void }) {
  return (
    <div className="feedback-templates">
      <h5>Quick feedback:</h5>
      {FEEDBACK_TEMPLATES.map(category => (
        <div key={category.category} className="template-category">
          <h6>{category.category}</h6>
          {category.templates.map(template => (
            <button 
              key={template}
              onClick={() => onSelect(template)}
              className="template-button"
            >
              {template}
            </button>
          ))}
        </div>
      ))}
    </div>
  );
}
```

## Performance Optimization

### Debounced Decision Updates

Prevent excessive API calls when users rapidly change decisions:

```typescript
function useDebouncedDecisions(delay = 300) {
  const [pendingDecisions, setPendingDecisions] = useState<Map<string, ApprovalDecision>>(new Map());
  const timeoutRef = useRef<NodeJS.Timeout>();
  
  const setDecision = useCallback((toolId: string, decision: ApprovalDecision) => {
    setPendingDecisions(prev => new Map(prev).set(toolId, decision));
    
    // Clear existing timeout
    if (timeoutRef.current) {
      clearTimeout(timeoutRef.current);
    }
    
    // Set new timeout to batch decision updates
    timeoutRef.current = setTimeout(() => {
      pendingDecisions.forEach((decision, toolId) => {
        ApprovalStateManager.setDecision(toolId, decision);
      });
      setPendingDecisions(new Map());
    }, delay);
  }, [pendingDecisions, delay]);
  
  return { setDecision };
}
```

### Optimistic UI Updates

Update UI immediately while API call is in progress:

```typescript
function useOptimisticBatchSubmit() {
  const [isSubmitting, setIsSubmitting] = useState(false);
  const [optimisticState, setOptimisticState] = useState<'submitting' | 'submitted' | null>(null);
  
  const submitBatch = useCallback(async (batchId: string, feedback?: string) => {
    setIsSubmitting(true);
    setOptimisticState('submitting');
    
    try {
      // Optimistic update
      ApprovalStateManager.markBatchAsSubmitted(batchId);
      
      // Actual API call
      await ApprovalStateManager.submitBatch(batchId, feedback);
      
      setOptimisticState('submitted');
    } catch (error) {
      // Revert optimistic update on error
      ApprovalStateManager.revertBatchSubmission(batchId);
      setOptimisticState(null);
      throw error;
    } finally {
      setIsSubmitting(false);
    }
  }, []);
  
  return {
    submitBatch,
    isSubmitting,
    isSubmittedOptimistically: optimisticState === 'submitted'
  };
}
```

## Next Steps

* Review [Error Handling](/human-in-the-loop/error-handling/index) for robust error management
* See [Implementation Examples](/human-in-the-loop/examples/index) for complete working code
* Learn about performance monitoring and analytics integration

# Error Handling
Source: https://docs.envole.ai/human-in-the-loop/error-handling/index

Managing the primary error case: mixed abort states

## Primary Error: Mixed Abort States

The only specific error you need to handle when implementing Human-in-the-Loop approvals is attempting to mix `ABORTED_WITH_FEEDBACK` states with `APPROVED` or `DENIED` states in a single batch.

### Error Response

When you submit a batch with mixed abort states, you'll receive an error response through the normal agent response mechanism:

```json
{
  "error": "Invalid approval batch: cannot mix ABORTED_WITH_FEEDBACK with other approval states",
  "batchId": "batch_456"
}
```

### Client-Side Prevention

The best approach is to prevent this error client-side through validation:

```typescript
function validateBatchStates(decisions: Map<string, ApprovalState>): ValidationResult {
  const states = Array.from(decisions.values());
  const hasAbort = states.includes('ABORTED_WITH_FEEDBACK');
  const hasOtherStates = states.some(state => state !== 'ABORTED_WITH_FEEDBACK');
  
  if (hasAbort && hasOtherStates) {
    return {
      valid: false,
      error: 'Cannot mix ABORTED_WITH_FEEDBACK with APPROVED or DENIED states'
    };
  }
  
  return { valid: true };
}

function onSubmitBatch(batchId: string) {
  const decisions = getBatchDecisions(batchId);
  const validation = validateBatchStates(decisions);
  
  if (!validation.valid) {
    showError(validation.error);
    return;
  }
  
  submitBatch(batchId, decisions);
}
```

## Other Error Scenarios

All other error scenarios (network failures, missing fields, incomplete batches, etc.) are handled through the normal agent response system. The agent will communicate these errors to the user naturally through conversation rather than specific error codes.

### Network Connection Handling

For connection issues with the SSE stream, implement basic reconnection logic:

```typescript
class ApprovalEventHandler {
  private eventSource: EventSource | null = null;
  private reconnectAttempts = 0;
  private maxReconnectAttempts = 3;
  
  connect(threadId: string) {
    this.eventSource = new EventSource(
      `${API_BASE_URL}/api/assistants/threads/${threadId}/stream`,
      { headers: { 'Authorization': `Bearer ${API_KEY}` } }
    );
    
    this.eventSource.onerror = () => {
      if (this.reconnectAttempts < this.maxReconnectAttempts) {
        this.reconnectAttempts++;
        setTimeout(() => this.connect(threadId), 1000 * this.reconnectAttempts);
      } else {
        showToast('Connection lost. Please refresh the page.', 'error');
      }
    };
    
    this.eventSource.onopen = () => {
      this.reconnectAttempts = 0;
    };
  }
}
```

## Next Steps

* See [Implementation Examples](/human-in-the-loop/examples/index) for complete error handling implementations
* Focus on client-side validation to prevent the mixed abort states error
* Let the agent handle all other error communication naturally

# Implementation Examples
Source: https://docs.envole.ai/human-in-the-loop/examples/index

Complete working code samples for Human-in-the-Loop integration

## Complete React Component Example

Here's a full implementation of a tool approval interface using React and TypeScript:

```typescript
import React, { useState, useEffect, useCallback } from 'react';

interface ToolApprovalRequest {
  toolId: string;
  toolName: string;
  toolProvider: string;
  toolCategory: string;
  toolExecutionId: string;
  toolExecutionBatchId: string;
  toolMemoryId: string;
  toolArguments: Record<string, any>;
  approvalResult: 'PENDING_HUMAN_APPROVAL';
}

interface BatchState {
  batchId: string;
  tools: ToolApprovalRequest[];
  decisions: Map<string, ApprovalDecision>;
  isComplete: boolean;
  canSubmit: boolean;
}

type ApprovalDecision = 'APPROVED' | 'DENIED' | 'ABORTED';

export function ToolApprovalInterface({ threadId, apiKey, userId }: {
  threadId: string;
  apiKey: string;
  userId: string;
}) {
  const [batches, setBatches] = useState<Map<string, BatchState>>(new Map());
  const [isSubmitting, setIsSubmitting] = useState<Set<string>>(new Set());
  const [feedback, setFeedback] = useState<Map<string, string>>(new Map());

// SSE Connection and Event Handling
  useEffect(() => {
    const eventSource = new EventSource(
      `${process.env.REACT_APP_API_BASE_URL}/api/assistants/threads/${threadId}/stream`,
      {
        headers: { 'Authorization': `Bearer ${apiKey}` }
      }
    );

eventSource.onmessage = (event) => {
      const data = JSON.parse(event.data);
      
      if (data.type === 'TOOL_EXECUTION_APPROVAL_REQUEST') {
        handleApprovalRequest(data.eventMessage.toolExecutionApprovalRequest);
      }
    };

eventSource.onerror = (error) => {
      console.error('SSE connection error:', error);
    };

return () => eventSource.close();
  }, [threadId, apiKey]);

const handleApprovalRequest = useCallback((requests: ToolApprovalRequest[]) => {
    const batchId = requests[0].toolExecutionBatchId;
    
    setBatches(prev => new Map(prev).set(batchId, {
      batchId,
      tools: requests,
      decisions: new Map(),
      isComplete: false,
      canSubmit: false
    }));
  }, []);

const validateBatchDecisions = (decisions: Map<string, ApprovalDecision>): boolean => {
    const states = Array.from(decisions.values());
    const hasAbort = states.includes('ABORTED');
    const hasOtherStates = states.some(state => state !== 'ABORTED');
    
    return !(hasAbort && hasOtherStates);
  };

const submitBatch = useCallback(async (batchId: string) => {
    const batch = batches.get(batchId);
    if (!batch || !batch.canSubmit) return;

setIsSubmitting(prev => new Set(prev).add(batchId));

try {
      const toolApprovalResults = batch.tools.map(tool => ({
        toolId: tool.toolId,
        toolName: tool.toolName,
        toolProvider: tool.toolProvider,
        toolCategory: tool.toolCategory,
        toolExecutionId: tool.toolExecutionId,
        toolExecutionBatchId: tool.toolExecutionBatchId,
        toolMemoryId: tool.toolMemoryId,
        toolArguments: tool.toolArguments,
        approvalResult: batch.decisions.get(tool.toolExecutionId)
      }));

const content = [];
      
      // Add feedback if provided
      const batchFeedback = feedback.get(batchId);
      if (batchFeedback) {
        content.push({
          type: 'text',
          text: batchFeedback
        });
      }

content.push({
        type: 'tool_approval_result',
        tool_approval_results: toolApprovalResults
      });

const response = await fetch(
        `${process.env.REACT_APP_API_BASE_URL}/api/assistants/threads/${threadId}/messages`,
        {
          method: 'POST',
          headers: {
            'Authorization': `Bearer ${apiKey}`,
            'Content-Type': 'application/json',
            'X-Envole-User-Id': userId
          },
          body: JSON.stringify({ content })
        }
      );

if (!response.ok) {
        const error = await response.json();
        throw new Error(error.message || 'Failed to submit approvals');
      }

// Remove completed batch
      setBatches(prev => {
        const newBatches = new Map(prev);
        newBatches.delete(batchId);
        return newBatches;
      });

setFeedback(prev => {
        const newFeedback = new Map(prev);
        newFeedback.delete(batchId);
        return newFeedback;
      });

} catch (error) {
      console.error('Failed to submit batch:', error);
      alert(`Failed to submit approvals: ${error.message}`);
    } finally {
      setIsSubmitting(prev => {
        const newSubmitting = new Set(prev);
        newSubmitting.delete(batchId);
        return newSubmitting;
      });
    }
  }, [batches, feedback, threadId, apiKey, userId]);

return (
    <div className="tool-approval-interface">
      <h2>Tool Approvals Required</h2>
      
      {Array.from(batches.values()).map(batch => (
        <BatchApprovalCard
          key={batch.batchId}
          batch={batch}
          onSetDecision={setDecision}
          onSubmit={() => submitBatch(batch.batchId)}
          isSubmitting={isSubmitting.has(batch.batchId)}
          feedback={feedback.get(batch.batchId) || ''}
          onFeedbackChange={(text) => setFeedback(prev => new Map(prev).set(batch.batchId, text))}
        />
      ))}
    </div>
  );
}

interface BatchApprovalCardProps {
  batch: BatchState;
  onSetDecision: (toolId: string, decision: ApprovalDecision) => void;
  onSubmit: () => void;
  isSubmitting: boolean;
  feedback: string;
  onFeedbackChange: (feedback: string) => void;
}

function BatchApprovalCard({
  batch,
  onSetDecision,
  onSubmit,
  isSubmitting,
  feedback,
  onFeedbackChange
}: BatchApprovalCardProps) {
  const [showFeedbackInput, setShowFeedbackInput] = useState(false);
  
  const decidedCount = batch.decisions.size;
  const totalCount = batch.tools.length;
  const hasAbortDecision = Array.from(batch.decisions.values()).includes('ABORTED');

const handleAbortAll = () => {
    batch.tools.forEach(tool => {
      onSetDecision(tool.toolExecutionId, 'ABORTED');
    });
    setShowFeedbackInput(true);
  };

const handleApproveAll = () => {
    batch.tools.forEach(tool => {
      onSetDecision(tool.toolExecutionId, 'APPROVED');
    });
  };

const handleDenyAll = () => {
    batch.tools.forEach(tool => {
      onSetDecision(tool.toolExecutionId, 'DENIED');
    });
  };

return (
    <div className="batch-card">
      <div className="batch-header">
        <h3>Batch {batch.batchId}</h3>
        <div className="batch-progress">
          {decidedCount} of {totalCount} tools decided
        </div>
      </div>

<div className="tools-list">
        {batch.tools.map(tool => (
          <ToolCard
            key={tool.toolExecutionId}
            tool={tool}
            decision={batch.decisions.get(tool.toolExecutionId)}
            onSetDecision={onSetDecision}
            disabled={hasAbortDecision}
          />
        ))}
      </div>

<div className="batch-actions">
        <div className="quick-actions">
          <button 
            onClick={handleApproveAll}
            disabled={hasAbortDecision || isSubmitting}
            className="approve-all-btn"
          >
            Approve All
          </button>
          <button 
            onClick={handleDenyAll}
            disabled={hasAbortDecision || isSubmitting}
            className="deny-all-btn"
          >
            Deny All
          </button>
          <button 
            onClick={handleAbortAll}
            disabled={isSubmitting}
            className="abort-all-btn"
          >
            Stop with Feedback
          </button>
        </div>

{showFeedbackInput && (
          <div className="feedback-section">
            <textarea
              value={feedback}
              onChange={(e) => onFeedbackChange(e.target.value)}
              placeholder="Explain why you're stopping these tools..."
              className="feedback-textarea"
              rows={3}
            />
          </div>
        )}

<button
          onClick={onSubmit}
          disabled={!batch.canSubmit || isSubmitting}
          className="submit-batch-btn"
        >
          {isSubmitting ? 'Submitting...' : 'Submit Decisions'}
        </button>
      </div>
    </div>
  );
}

interface ToolCardProps {
  tool: ToolApprovalRequest;
  decision?: ApprovalDecision;
  onSetDecision: (toolId: string, decision: ApprovalDecision) => void;
  disabled: boolean;
}

function ToolCard({ tool, decision, onSetDecision, disabled }: ToolCardProps) {
  return (
    <div className={`tool-card ${decision ? `decided-${decision.toLowerCase()}` : 'undecided'}`}>
      <div className="tool-header">
        <h4>{tool.toolName}</h4>
        <span className="tool-provider">{tool.toolProvider}</span>
      </div>

<div className="tool-arguments">
        <h5>Arguments:</h5>
        <pre>{JSON.stringify(tool.toolArguments, null, 2)}</pre>
      </div>

<div className="tool-actions">
        <button
          onClick={() => onSetDecision(tool.toolExecutionId, 'APPROVED')}
          disabled={disabled}
          className={`action-btn approve-btn ${decision === 'APPROVED' ? 'active' : ''}`}
        >
          ✓ Approve
        </button>
        <button
          onClick={() => onSetDecision(tool.toolExecutionId, 'DENIED')}
          disabled={disabled}
          className={`action-btn deny-btn ${decision === 'DENIED' ? 'active' : ''}`}
        >
          ✕ Deny
        </button>
      </div>

{decision && (
        <div className="decision-indicator">
          Decision: <strong>{decision}</strong>
        </div>
      )}
    </div>
  );
}
```

This example provides a complete, working implementations that you can adapt to your specific application architecture and requirements. The key patterns demonstrated include proper batch management, state validation, error handling, and API integration following the documented constraints and best practices.

# Human-in-the-Loop Overview
Source: https://docs.envole.ai/human-in-the-loop/introduction/index

Introduction to tool approval and human oversight via SSE API

## Prerequisites

This document assumes you have already implemented basic Envole API integration following our [API Integration Guide](/sub-assistants/api-integration/index), including:

* Authentication setup with Bearer tokens and X-Envole-User-Id headers
* Thread creation and basic message posting
* EventSource setup for SSE streaming
* Basic event processing (AGENT\_RESPONSE\_CHUNK, AGENT\_RESPONSE\_COMPLETE)

## Overview

Human-in-the-Loop (HITL) enables oversight and approval controls for AI agent tool executions. When agents attempt to execute sensitive tools (like sending emails, creating calendar events, or modifying databases), the system can pause execution and request human approval before proceeding.

This approval system operates through Server-Sent Events (SSE) and provides fine-grained control over agent actions while maintaining a smooth user experience.

## How Tool Approval Works

### Basic Flow

1. **Agent Action**: An agent attempts to execute a tool requiring approval
2. **Approval Request**: System emits `TOOL_EXECUTION_APPROVAL_REQUEST` event
3. **Human Decision**: User reviews tool arguments and decides to approve, deny, or abort
4. **Batch Response**: All approvals in the batch are responded to simultaneously
5. **Tool Execution**: Approved tools execute; denied/aborted tools are skipped
6. **Agent Response**: Agent continues with execution results

### Key Concepts

**Tool Execution Batches**: Multiple tool calls requiring approval are grouped by `toolExecutionBatchId`. All tools in a batch must be responded to together - individual responses will cause premature batch completion.

**Approval States**: Each tool can be approved, denied, or aborted with feedback. Mixed states are allowed (approve some, deny others) except for aborts, which must stand alone.

**Content Integration**: Tool approval responses are sent through the standard message API, with approval results included in the content field.

## When to Use Human-in-the-Loop

Human oversight is valuable for:

* **High-stakes actions**: Database modifications, financial transactions, external communications
* **Compliance requirements**: Actions requiring audit trails or explicit approval
* **Learning systems**: Allowing users to guide agent behavior through feedback
* **Quality control**: Ensuring agent actions meet organizational standards

## Next Steps

* Learn about [SSE Events](/human-in-the-loop/sse-events/index) for handling approval requests
* Understand [Batch Management](/human-in-the-loop/batch-management/index) for proper response handling
* Review [API Integration](/human-in-the-loop/api-integration/index) for implementation details

# SSE Events for Tool Approval
Source: https://docs.envole.ai/human-in-the-loop/sse-events/index

Complete reference for human-in-the-loop event types and payloads

Human-in-the-Loop functionality operates through Server-Sent Events (SSE) that notify your application when tool approvals are required and provide status updates throughout the approval process.

## Core Approval Events

### `TOOL_EXECUTION_APPROVAL_REQUEST`

Emitted when an agent requires human approval to execute one or more tools. This is the primary event that triggers approval UI in your application.

```json
{
  "type": "TOOL_EXECUTION_APPROVAL_REQUEST",
  "eventId": "evt_5",
  "threadId": "thread_456",
  "requestId": "req_1",
  "eventMessage": {
    "agent": null,
    "content": "",
    "collaborationId": null,
    "activeAssistantCollaborationRequired": null,
    "toolExecutionApprovalRequest": [
      {
        "toolId": "tool_123",
        "toolName": "google_calendar_create_event",
        "toolProvider": "GOOGLE_CALENDAR",
        "toolCategory": "CALENDAR",
        "toolExecutionId": "exec_123",
        "toolExecutionBatchId": "batch_456",
        "toolMemoryId": "mem_789",
        "toolArguments": {
          "event_title": "Project Review Meeting",
          "start_time": "2024-01-15T14:00:00Z",
          "end_time": "2024-01-15T15:00:00Z",
          "attendees": "john@company.com,mary@company.com",
          "location": "Conference Room A"
        },
        "approvalResult": "PENDING_HUMAN_APPROVAL"
      }
    ],
    "timestamp": "2025-08-12T00:00:03"
  }
}
```

**Key Fields:**

* `toolExecutionBatchId`: Groups related tool executions that must be approved together
* `toolExecutionId`: Unique identifier for this specific tool execution
* `toolArguments`: The actual parameters the agent wants to pass to the tool
* `approvalResult`: Always "PENDING\_HUMAN\_APPROVAL" for request events

## Notification Events

These events provide status updates during the approval lifecycle:

### `NOTIFICATION_TOOL_EXECUTION_APPROVAL_REQUIRED`

General notification that tool approval is needed.

```json
{
  "type": "NOTIFICATION_TOOL_EXECUTION_APPROVAL_REQUIRED",
  "eventId": "evt_1",
  "threadId": "thread_456", 
  "requestId": "req_1",
  "eventMessage": {
    "agent": null,
    "content": "tool execution requires approval",
    "collaborationId": null,
    "activeAssistantCollaborationRequired": null,
    "toolExecutionApprovalRequest": null,
    "timestamp": "2025-08-12T00:00:00"
  }
}
```

### `NOTIFICATION_TOOL_EXECUTION_APPROVAL_ACCEPTED`

Emitted when a tool execution has been approved.

```json
{
  "type": "NOTIFICATION_TOOL_EXECUTION_APPROVAL_ACCEPTED",
  "eventId": "evt_1", 
  "threadId": "thread_456",
  "requestId": "req_1",
  "eventMessage": {
    "agent": null,
    "content": "tool execution approved",
    "collaborationId": null,
    "activeAssistantCollaborationRequired": null,
    "toolExecutionApprovalRequest": null,
    "timestamp": "2025-08-12T00:00:00"
  }
}
```

### `NOTIFICATION_TOOL_EXECUTION_APPROVAL_DENIED`

Emitted when a tool execution has been denied.

```json
{
  "type": "NOTIFICATION_TOOL_EXECUTION_APPROVAL_DENIED",
  "eventId": "evt_1",
  "threadId": "thread_456",
  "requestId": "req_1", 
  "eventMessage": {
    "agent": null,
    "content": "tool execution denied",
    "collaborationId": null,
    "activeAssistantCollaborationRequired": null,
    "toolExecutionApprovalRequest": null,
    "timestamp": "2025-08-12T00:00:00"
  }
}
```

### `NOTIFICATION_TOOL_EXECUTION_APPROVAL_ABORTED`

Emitted when a tool execution has been aborted with feedback.

```json
{
  "type": "NOTIFICATION_TOOL_EXECUTION_APPROVAL_ABORTED",
  "eventId": "evt_1",
  "threadId": "thread_456",
  "requestId": "req_1",
  "eventMessage": {
    "agent": null,
    "content": "tool execution aborted with feedback", 
    "collaborationId": null,
    "activeAssistantCollaborationRequired": null,
    "toolExecutionApprovalRequest": null,
    "timestamp": "2025-08-12T00:00:00"
  }
}
```

## Related Tool Execution Events

### `NOTIFICATION_TOOL_EXECUTION_INITIATED`

Tool execution has started (after approval, if required).

```json
{
  "type": "NOTIFICATION_TOOL_EXECUTION_INITIATED",
  "eventId": "evt_1",
  "threadId": "thread_456",
  "requestId": "req_1",
  "eventMessage": {
    "agent": null,
    "content": "tool execution started",
    "collaborationId": null,
    "activeAssistantCollaborationRequired": null,
    "toolExecutionApprovalRequest": null,
    "timestamp": "2025-08-12T00:00:00"
  }
}
```

### `NOTIFICATION_TOOL_EXECUTION_IN_PROGRESS`

Tool execution is currently running.

```json
{
  "type": "NOTIFICATION_TOOL_EXECUTION_IN_PROGRESS",
  "eventId": "evt_1",
  "threadId": "thread_456",
  "requestId": "req_1",
  "eventMessage": {
    "agent": null,
    "content": "tool execution in progress",
    "collaborationId": null,
    "activeAssistantCollaborationRequired": null,
    "toolExecutionApprovalRequest": null,
    "timestamp": "2025-08-12T00:00:00"
  }
}
```

## Event Handling Implementation

```typescript
const eventSource = new EventSource(`${API_BASE_URL}/${threadId}/stream`, {
  headers: { 'Authorization': `Bearer ${API_KEY}` }
});

eventSource.addEventListener('message', (event) => {
  const data = JSON.parse(event.data);
  
  switch (data.type) {
    case 'TOOL_EXECUTION_APPROVAL_REQUEST':
      handleApprovalRequest(data.eventMessage.toolExecutionApprovalRequest);
      break;
      
    case 'NOTIFICATION_TOOL_EXECUTION_APPROVAL_REQUIRED':
      showApprovalRequiredNotification();
      break;
      
    case 'NOTIFICATION_TOOL_EXECUTION_APPROVAL_ACCEPTED':
      updateToolStatus('approved');
      break;
      
    case 'NOTIFICATION_TOOL_EXECUTION_APPROVAL_DENIED':
      updateToolStatus('denied');
      break;
      
    case 'NOTIFICATION_TOOL_EXECUTION_APPROVAL_ABORTED':
      updateToolStatus('aborted');
      break;
      
    case 'NOTIFICATION_TOOL_EXECUTION_INITIATED':
      showToolExecutionStarted();
      break;
      
    case 'NOTIFICATION_TOOL_EXECUTION_IN_PROGRESS':
      updateExecutionProgress();
      break;
  }
});
```

## Next Steps

* Learn about [Batch Management](/human-in-the-loop/batch-management/index) for handling multiple approvals
* Understand [Approval States](/human-in-the-loop/approval-states/index) and their constraints
* See [Implementation Examples](/human-in-the-loop/examples/index) for complete code samples

# Welcome to Envole
Source: https://docs.envole.ai/introduction

Your AI-powered platform for team productivity and collaboration

Welcome to Envole, where AI meets team productivity. Envole transforms how teams work by providing intelligent assistants that integrate with your existing tools, automate repetitive tasks, and facilitate seamless collaboration across departments.

## What is Envole?

Envole is an AI platform designed to enhance team productivity through two core types of assistants:

**Team Personal Assistants (PAs)** - Your dedicated team orchestrators that proactively organize information, sync tools, manage meetings, and coordinate workflows. Each team gets its own PA that understands your context and keeps everyone aligned.

**Sub-Assistants** - Specialized, user-created helpers that automate specific workflows and tasks. Built with our no-code workflow builder, these assistants handle everything from generating campaign briefs to summarizing support tickets.

## Key Benefits

<CardGroup cols={2}>
  <Card title="Seamless Integration" icon="link">
    Connect with tools your team already uses - Slack, Jira, Notion, Google Drive, and dozens more
  </Card>

<Card title="Intelligent Automation" icon="robot">
    Automate repetitive tasks and let AI handle the busywork while your team focuses on high-value activities
  </Card>

<Card title="Cross-Team Collaboration" icon="users">
    Break down silos with assistants that can collaborate across departments using simple @-mentions
  </Card>

<Card title="Always Learning" icon="brain">
    Your assistants learn from your team's context, documents, and workflows to provide increasingly valuable insights
  </Card>
</CardGroup>

## How Teams Use Envole

**Product Teams** use Team PAs to track project status, generate meeting agendas from recent activities, and coordinate between engineering and design. Sub-assistants help create PRDs, summarize user feedback, and maintain technical documentation.

**Sales Teams** rely on their PA to surface lead insights, track deal progress, and sync information across CRM systems. Custom sub-assistants research prospects, draft follow-up emails, and compile competitive intelligence.

**Marketing Teams** leverage their PA to coordinate campaigns across channels and track performance metrics. Sub-assistants generate campaign briefs, create social media content, and analyze campaign results.

## What's Next?

Ready to explore how Envole can transform your team's productivity? Let's start with a tour of the platform.

<Card title="Take the Platform Tour" icon="map" href="/getting-started/tour">
  Discover Envole's interface and see how Team Personal Assistants work
</Card>

## Additional Resources

<CardGroup cols={3}>
  <Card title="Try Envole" icon="paper-plane-top" href="https://envole.ai">
    Get started with your team today
  </Card>

<Card title="Talk to a Founder" icon="calendar" href="https://cal.com/rogerbukuru/envole-discovery-call?duration=30">
    Schedule a discovery call
  </Card>

<Card title="API Reference" icon="code" href="/api-reference/introduction">
    Integrate Envole into your applications
  </Card>
</CardGroup>

# Implementation Best Practices
Source: https://docs.envole.ai/multi-assistant-collaboration/best-practices/index

Best practices for implementing collaboration features effectively

## Implementation Patterns

### UI Integration

Create responsive UI that reflects collaboration state using React:

```jsx
import React, { useState, useEffect } from 'react';

// Main collaboration component
const CollaborationManager = ({ collaborationManager }) => {
    const [activeCollaborations, setActiveCollaborations] = useState(new Map());

useEffect(() => {
        const handleCollaborationStarted = (event) => {
            const { agents, id } = event.detail;
            setActiveCollaborations(prev => new Map(prev.set(id, {
                id,
                agents,
                phase: 'started',
                agentStatuses: new Map(agents.map(agent => [agent.handle, 'pending']))
            })));
        };

// Add event listeners
        document.addEventListener('collaboration_started', handleCollaborationStarted);
        document.addEventListener('agent_status_updated', handleAgentStatusUpdated);
        document.addEventListener('collaboration_completed', handleCollaborationCompleted);

return () => {
            document.removeEventListener('collaboration_started', handleCollaborationStarted);
            document.removeEventListener('agent_status_updated', handleAgentStatusUpdated);
            document.removeEventListener('collaboration_completed', handleCollaborationCompleted);
        };
    }, []);

return (
        <div className="collaboration-container">
            {Array.from(activeCollaborations.values()).map(collaboration => (
                <CollaborationStatus 
                    key={collaboration.id}
                    collaboration={collaboration}
                />
            ))}
        </div>
    );
};

// Individual collaboration status component
const CollaborationStatus = ({ collaboration }) => {
    const { id, agents, phase, agentStatuses } = collaboration;

return (
        <div className="collaboration-status" data-collaboration={id}>
            <div className="collaboration-header">
                <span className="collaboration-phase">{phase}</span>
                <span className="collaboration-id">ID: {id}</span>
            </div>
            <div className="participating-agents">
                {agents.map(agent => (
                    <AgentStatus 
                        key={agent.handle}
                        agent={agent}
                        status={agentStatuses.get(agent.handle) || 'pending'}
                    />
                ))}
            </div>
        </div>
    );
};

// Individual agent status component
const AgentStatus = ({ agent, status }) => {
    const statusClass = `agent-status-indicator ${status}`;
    
    return (
        <div className="agent-status" data-agent={agent.handle}>
            <span className="agent-name">@{agent.handle}</span>
            <span className={statusClass}>{status}</span>
        </div>
    );
};
```

### Message Filtering

Filter messages during collaboration for better UX using React hooks:

```jsx
import React, { useState, useEffect, useCallback } from 'react';

const MessageManager = ({ sseClient }) => {
    const [messages, setMessages] = useState([]);
    const [messageQueue, setMessageQueue] = useState([]);
    const [activeCollaborations, setActiveCollaborations] = useState(new Set());

const isCollaborationActive = useCallback(() => {
        return activeCollaborations.size > 0;
    }, [activeCollaborations]);

const isIndividualAgentResponse = useCallback((message) => {
        return message.collaborationId && !message.isUnifiedResponse;
    }, []);

const handleMessage = useCallback((message) => {
        // During collaboration, queue individual agent messages
        if (isCollaborationActive() && isIndividualAgentResponse(message)) {
            setMessageQueue(prev => [...prev, message]);
            return; // Don't display yet
        }
        
        // Display unified response or non-collaboration messages immediately
        setMessages(prev => [...prev, message]);
    }, [isCollaborationActive, isIndividualAgentResponse]);

useEffect(() => {
        const handleCollaborationStarted = (event) => {
            const { id } = event.detail;
            setActiveCollaborations(prev => new Set(prev.add(id)));
        };

const handleCollaborationCompleted = (event) => {
            const { id } = event.detail;
            handleCollaborationComplete(id);
        };

document.addEventListener('collaboration_started', handleCollaborationStarted);
        document.addEventListener('collaboration_completed', handleCollaborationCompleted);

return () => {
            document.removeEventListener('collaboration_started', handleCollaborationStarted);
            document.removeEventListener('collaboration_completed', handleCollaborationCompleted);
        };
    }, [handleCollaborationComplete]);

return (
        <div className="message-container">
            {messages.map((message, index) => (
                <MessageComponent key={index} message={message} />
            ))}
        </div>
    );
};

const MessageComponent = ({ message }) => {
    return (
        <div className={`message ${message.role}`}>
            <div className="message-content">{message.content}</div>
            {message.collaborationId && (
                <div className="collaboration-badge">
                    Collaboration: {message.collaborationId}
                </div>
            )}
        </div>
    );
};
```

## Best Practices

### 1. Performance Optimization

* **Event Filtering**: Only process collaboration events when needed
* **State Cleanup**: Remove completed collaborations from memory
* **Batch Updates**: Group UI updates for better performance

### 2. User Experience

* **Real-time Feedback**: Show collaboration progress and participating agents
* **Error Recovery**: Provide clear error messages and retry options
* **Loading States**: Display appropriate loading indicators during planning and execution

### 3. Scalability

* **Connection Management**: Implement proper reconnection logic
* **Memory Management**: Clean up completed collaboration state
* **Rate Limiting**: Handle API rate limits gracefully

### 4. Error Handling

* **Graceful Degradation**: Fall back to individual responses on collaboration failure
* **User Communication**: Provide clear feedback on collaboration status
* **Logging**: Log collaboration events for debugging and monitoring

### 5. Testing Collaboration

Test collaboration scenarios:

```javascript
// Test collaboration detection
const testMessage = {
    content: [{
        type: "text", 
        text: "@product @engineering work on auth feature"
    }]
};

// Test error scenarios
const invalidMessage = {
    content: [{
        type: "text",
        text: "@nonexistent @invalid collaborate"
    }]
};

// Monitor events during testing
function testCollaborationFlow() {
    const events = [];
    
    document.addEventListener('collaboration_started', (e) => {
        events.push({ type: 'started', data: e.detail });
    });
    
    document.addEventListener('collaboration_completed', (e) => {
        events.push({ type: 'completed', data: e.detail });
        console.log('Collaboration test results:', events);
    });
}
```

## Conclusion

This SSE-based collaboration system provides a robust foundation for building multi-agent workflows. By building upon the existing API Integration Guide, you can implement sophisticated collaboration features that enhance user productivity through seamless agent-to-agent communication.

The 12 collaboration events provide complete visibility into the collaboration lifecycle, enabling you to build responsive, user-friendly interfaces that keep users informed throughout the collaborative process.

# Collaboration Detection
Source: https://docs.envole.ai/multi-assistant-collaboration/collaboration-detection/index

How the system detects and initiates collaboration workflows

## Collaboration Detection and Workflow

### Automatic Detection

When the SSE API receives a message containing multiple @-mentions, it automatically:

1. Detects collaboration requirement
2. Initiates planning phase
3. Coordinates agent responses
4. Optionally synthesizes unified response

### Message Structure for Collaboration

Use the existing message endpoint with @-mentions in content:

```javascript
const response = await fetch(`/api/assistants/threads/${threadId}/messages`, {
    method: 'POST',
    headers: {
        'Authorization': `Bearer ${apiKey}`,
        'X-Envole-User-Id': userId,
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        content: [{
            type: "text",
            text: "@product @engineering work together on user authentication feature"
        }]
    })
});
```

# Error Handling
Source: https://docs.envole.ai/multi-assistant-collaboration/error-handling/index

Handling collaboration errors and connection management

## Error Handling

### Collaboration-Specific Errors

Handle collaboration failures gracefully:

```javascript
handleCollaborationError(event) {
    const { eventMessage, type } = event;
    
    switch (type) {
        case 'NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_FAILED':
            console.error('Collaboration failed:', eventMessage.content);
            this.showUserError('Collaboration could not be completed. Please try again.');
            break;
            
        case 'ERROR_INVALID_COLLABORATION_REQUEST':
            console.error('Invalid collaboration request:', eventMessage.content);
            this.showUserError('Invalid collaboration request. Please check agent handles.');
            break;
            
        default:
            // Handle other collaboration errors
            console.error('Collaboration error:', eventMessage.content);
            this.showUserError('An error occurred during collaboration.');
    }
}

showUserError(message) {
    // Show error to user in your UI
    document.dispatchEvent(new CustomEvent('collaboration_error', { 
        detail: { message } 
    }));
}
```

### Connection Management

Build upon existing SSE connection management for collaboration:

```javascript
class RobustCollaborationClient extends EnhancedSSEClient {
    constructor(threadId, apiKey, userId) {
        super(threadId, apiKey, userId);
        this.reconnectAttempts = 0;
        this.maxReconnectAttempts = 3;
    }

setupEventSource() {
        super.setupEventSource();
        
        this.eventSource.onerror = (error) => {
            console.error('SSE connection error:', error);
            
            if (this.reconnectAttempts < this.maxReconnectAttempts) {
                this.reconnectAttempts++;
                setTimeout(() => {
                    console.log(`Reconnecting... Attempt ${this.reconnectAttempts}`);
                    this.setupEventSource();
                }, 1000 * this.reconnectAttempts);
            } else {
                this.showUserError('Connection lost. Please refresh the page.');
            }
        };

this.eventSource.onopen = () => {
            console.log('SSE connection established');
            this.reconnectAttempts = 0;
        };
    }
}
```

# Message Flow Examples
Source: https://docs.envole.ai/multi-assistant-collaboration/examples/index

Real-world examples of collaboration message flows and event sequences

## Message Flow Examples

### Example 1: Simple Collaboration

**User Message**: `"@product @engineering work together on user authentication"`

**Event Sequence**:

1. `NOTIFICATION_REQUEST_ORCHESTRATION_COLLABORATION_REQUEST` - System detects collaboration
2. `NOTIFICATION_PLAN_ORCHESTRATION_COLLABORATION_PLANNING_INITIATED` - Planning begins
3. `NOTIFICATION_PLAN_ORCHESTRATION_COLLABORATION_PLANNING_COMPLETED` - Planning complete
4. `NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_STARTED` - Collaboration session starts
   * Contains: collaborationId, list of @product and @engineering agents
5. `NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_ASSISTANT_RESPONSE_IN_PROGRESS` - @product starts responding
6. `NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_ASSISTANT_RESPONSE_COMPLETED` - @product finishes
7. `NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_ASSISTANT_RESPONSE_IN_PROGRESS` - @engineering starts responding
8. `NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_ASSISTANT_RESPONSE_COMPLETED` - @engineering finishes
9. `NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_UNIFIED_RESPONSE_STARTED` - System synthesizes responses
10. `NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_COMPLETED` - Collaboration complete

### Example 2: No Unified Response Required

**User Message**: `"@support help @sales with this customer issue"`

**Event Sequence**:

1. `NOTIFICATION_REQUEST_ORCHESTRATION_COLLABORATION_REQUEST`
2. `NOTIFICATION_PLAN_ORCHESTRATION_COLLABORATION_PLANNING_INITIATED`
3. `NOTIFICATION_PLAN_ORCHESTRATION_COLLABORATION_PLANNING_COMPLETED`
4. `NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_STARTED`
5. `NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_ASSISTANT_RESPONSE_IN_PROGRESS` - @support responds
6. `NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_ASSISTANT_RESPONSE_COMPLETED` - @support done
7. `NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_ASSISTANT_RESPONSE_IN_PROGRESS` - @sales responds
8. `NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_ASSISTANT_RESPONSE_COMPLETED` - @sales done
9. `NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_NO_UNIFIED_RESPONSE_REQUIRED` - Individual responses sufficient
10. `NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_COMPLETED`

# SSE Integration
Source: https://docs.envole.ai/multi-assistant-collaboration/integration/index

Integrating collaboration events with your SSE event handling

## Advanced SSE Integration

### Collaboration-Specific Event Processing

Extend your existing EventSource handling to process collaboration events:

```javascript
class EnhancedSSEClient {
    constructor(threadId, apiKey, userId) {
        this.threadId = threadId;
        this.apiKey = apiKey;
        this.userId = userId;
        this.collaborationManager = new CollaborationManager();
        this.setupEventSource();
    }

setupEventSource() {
        // Build upon existing SSE setup from API Integration Guide
        this.eventSource = new EventSource(`/api/assistants/threads/${this.threadId}/messages/stream`, {
            headers: {
                'Authorization': `Bearer ${this.apiKey}`,
                'X-Envole-User-Id': this.userId
            }
        });

this.eventSource.onmessage = (event) => {
            const data = JSON.parse(event.data);
            
            // Handle collaboration events
            if (this.isCollaborationEvent(data.type)) {
                this.collaborationManager.handleSSEEvent(data);
            }
            
            // Continue with existing event handling for other events
            this.handleStandardEvents(data);
        };
    }

isCollaborationEvent(eventType) {
        const collaborationEvents = [
            'NOTIFICATION_REQUEST_ORCHESTRATION_COLLABORATION_REQUEST',
            'NOTIFICATION_PLAN_ORCHESTRATION_COLLABORATION_PLANNING_INITIATED',
            'NOTIFICATION_PLAN_ORCHESTRATION_COLLABORATION_PLANNING_IN_PROGRESS',
            'NOTIFICATION_PLAN_ORCHESTRATION_COLLABORATION_PLANNING_COMPLETED',
            'NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_STARTED',
            'NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_ASSISTANT_RESPONSE_IN_PROGRESS',
            'NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_ASSISTANT_RESPONSE_COMPLETED',
            'NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_COMPLETED',
            'NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_UNIFIED_RESPONSE_STARTED',
            'NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_NO_UNIFIED_RESPONSE_REQUIRED',
            'NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_FAILED',
            'ERROR_INVALID_COLLABORATION_REQUEST'
        ];
        
        return collaborationEvents.includes(eventType);
    }

handleStandardEvents(data) {
        // Your existing event handling from API Integration Guide
        // AGENT_RESPONSE_CHUNK, AGENT_RESPONSE_COMPLETE, etc.
    }
}
```

# Multi-Assistant Collaboration Overview
Source: https://docs.envole.ai/multi-assistant-collaboration/introduction/index

Introduction to cross-agent collaboration via SSE API

## Prerequisites

This document assumes you have already implemented basic Envole API integration following our [API Integration Guide](https://docs.envole.ai/getting-started-section/api-integration), including:

## Overview

Cross-agent collaboration enables multiple specialized agents to work together on complex tasks through a simple @-mention system. When users mention multiple agents in a message (e.g., "@product and @engineering, work together on this feature spec"), the platform automatically orchestrates a collaborative workflow where each mentioned agent contributes their expertise, and optionally provides a unified response.

## Agent Handle System

### What are Agent Handles?

Agent handles are unique identifiers (like "@product", "@support", "@legal") that allow users to invoke specific agents in conversations. Each agent must have a unique handle within an organization.

### Handle Structure

```typescript
interface Agent {
    id: string;
    name: string;
    handle: string;  // Unique handle without @ symbol (e.g., "product")
    // ... other properties
}
```

### Using Handles in Messages

Users invoke collaboration by mentioning agents in their messages:

```javascript
// Single agent
"@product what features should we prioritize next quarter?"

// Multiple agents (triggers collaboration)
"@product and @engineering, can you work together on the new feature spec?"
"I need @support to help @sales with the customer issue"
"@legal @finance review this contract together"
```

# Collaboration SSE Events
Source: https://docs.envole.ai/multi-assistant-collaboration/sse-events/index

Complete reference for all collaboration-related Server-Sent Events

## Complete Collaboration Events

The SSE stream includes 12 specific collaboration events that track the complete collaboration lifecycle:

### Planning Phase Events (4)

1. **`NOTIFICATION_REQUEST_ORCHESTRATION_COLLABORATION_REQUEST`**
   * **Description**: Collaboration detected and planning initiated
   * **When**: Triggered when multiple @-mentions are detected in user message
   * **Purpose**: Indicates system has recognized need for collaboration

2. **`NOTIFICATION_PLAN_ORCHESTRATION_COLLABORATION_PLANNING_INITIATED`**
   * **Description**: Collaboration planning started
   * **When**: System begins analyzing collaboration requirements
   * **Purpose**: Planning phase has begun

3. **`NOTIFICATION_PLAN_ORCHESTRATION_COLLABORATION_PLANNING_IN_PROGRESS`**
   * **Description**: Collaboration planning in progress
   * **When**: During active planning phase
   * **Purpose**: System is determining collaboration strategy

4. **`NOTIFICATION_PLAN_ORCHESTRATION_COLLABORATION_PLANNING_COMPLETED`**
   * **Description**: Collaboration planning completed
   * **When**: Planning phase finishes successfully
   * **Purpose**: Collaboration strategy determined, moving to execution

### Execution Phase Events (4)

5. **`NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_STARTED`**
   * **Description**: Collaboration session started
   * **When**: Active collaboration begins
   * **Purpose**: Agents begin working on the collaborative task
   * **Contains**: List of participating agents and collaboration ID

6. **`NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_ASSISTANT_RESPONSE_IN_PROGRESS`**
   * **Description**: Agent responding
   * **When**: Individual agent is actively generating response
   * **Purpose**: Track which agents are currently responding

7. **`NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_ASSISTANT_RESPONSE_COMPLETED`**
   * **Description**: Agent response completed
   * **When**: Individual agent finishes their contribution
   * **Purpose**: Track completion of individual agent responses

8. **`NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_COMPLETED`**
   * **Description**: All agents finished
   * **When**: All participating agents have completed their responses
   * **Purpose**: Collaboration execution phase complete

### Response Phase Events (3)

9. **`NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_UNIFIED_RESPONSE_STARTED`**
   * **Description**: Unified response generation started
   * **When**: System begins synthesizing individual responses
   * **Purpose**: Creating cohesive response from multiple agent inputs

10. **`NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_NO_UNIFIED_RESPONSE_REQUIRED`**
    * **Description**: No unified response needed
    * **When**: System determines individual responses are sufficient
    * **Purpose**: Skips unification step

11. **`NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_FAILED`**
    * **Description**: Collaboration failed
    * **When**: Error occurs during collaboration process
    * **Purpose**: Indicates collaboration could not complete successfully

### Error Handling Event (1)

12. **`ERROR_INVALID_COLLABORATION_REQUEST`**
    * **Description**: Invalid collaboration request error
    * **When**: Malformed collaboration request detected
    * **Purpose**: Validation error for collaboration setup

## Event Structure for Collaboration

Collaboration events follow the standard SSE event structure with additional collaboration-specific fields:

```javascript
{
    "type": "NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_STARTED",
    "eventId": "evt_12345",
    "threadId": "thread_abc123",
    "requestId": "req_567890",
    "eventMessage": {
        "agent": {
            "id": "agent_001",
            "name": "Product Assistant", 
            "handle": "product"
        },
        "content": "Starting collaboration...",
        "collaborationId": "collab_xyz789",                    // Unique collaboration session ID
        "collaboratingAssistants": [                           // Array of participating agents
            {
                "id": "agent_001",
                "name": "Product Assistant",
                "handle": "product"
            },
            {
                "id": "agent_002", 
                "name": "Engineering Assistant",
                "handle": "engineering"
            }
        ],
        "activeAssistantCollaborationRequired": true,          // Whether active assistant participates
        "toolExecutionApprovalRequest": null,
        "timestamp": "2025-08-12T10:30:00Z"
    }
}
```

# Collaboration State Management
Source: https://docs.envole.ai/multi-assistant-collaboration/state-management/index

Managing and tracking collaboration state throughout the lifecycle

## Collaboration State Management

### Tracking Collaboration State

Build upon your existing SSE event handling to track collaboration state:

```javascript
class CollaborationManager {
    constructor() {
        this.activeCollaborations = new Map();
    }

handleSSEEvent(event) {
        const { type, eventMessage } = event;
        const { collaborationId, collaboratingAssistants } = eventMessage;

switch (type) {
            case 'NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_STARTED':
                this.startCollaboration(collaborationId, collaboratingAssistants);
                break;
                
            case 'NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_ASSISTANT_RESPONSE_IN_PROGRESS':
                this.updateAgentStatus(collaborationId, eventMessage.agent.handle, 'responding');
                break;
                
            case 'NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_ASSISTANT_RESPONSE_COMPLETED':
                this.updateAgentStatus(collaborationId, eventMessage.agent.handle, 'completed');
                break;
                
            case 'NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_COMPLETED':
                this.completeCollaboration(collaborationId);
                break;
                
            case 'NOTIFICATION_MULTI_ASSISTANT_COLLABORATION_FAILED':
                this.failCollaboration(collaborationId, eventMessage.content);
                break;
        }
    }

startCollaboration(collaborationId, agents) {
        const collaboration = {
            id: collaborationId,
            agents: new Map(agents.map(agent => [agent.handle, {
                ...agent,
                status: 'pending'
            }])),
            phase: 'started',
            startTime: new Date().toISOString()
        };
        
        this.activeCollaborations.set(collaborationId, collaboration);
        this.notifyUI('collaboration_started', collaboration);
    }

updateAgentStatus(collaborationId, agentHandle, status) {
        const collaboration = this.activeCollaborations.get(collaborationId);
        if (collaboration && collaboration.agents.has(agentHandle)) {
            collaboration.agents.get(agentHandle).status = status;
            this.notifyUI('agent_status_updated', { collaborationId, agentHandle, status });
        }
    }

completeCollaboration(collaborationId) {
        const collaboration = this.activeCollaborations.get(collaborationId);
        if (collaboration) {
            collaboration.phase = 'completed';
            collaboration.endTime = new Date().toISOString();
            this.notifyUI('collaboration_completed', collaboration);
            this.activeCollaborations.delete(collaborationId);
        }
    }

failCollaboration(collaborationId, error) {
        const collaboration = this.activeCollaborations.get(collaborationId);
        if (collaboration) {
            collaboration.phase = 'failed';
            collaboration.error = error;
            collaboration.endTime = new Date().toISOString();
            this.notifyUI('collaboration_failed', collaboration);
            this.activeCollaborations.delete(collaborationId);
        }
    }

notifyUI(eventType, data) {
        // Emit events to update your UI
        document.dispatchEvent(new CustomEvent(eventType, { detail: data }));
    }
}
```

# API Integration
Source: https://docs.envole.ai/sub-assistants/api-integration/index

This guide walks through every step required to interact with the Session Thread API. It assumes no prior knowledge and shows how to obtain credentials, create threads, send messages, and process streaming events.

## 1. Obtain credentials

1. Sign in to the Envole dashboard.
2. Navigate to **API Keys** and create a new key.
3. Choose or generate a unique identifier for the end user. This value will be sent in the required `X-Envole-User-Id` header on every request.
4. Store both values in environment variables:

```bash
export ENVOLE_API_KEY="sk-your-key"
export ENVOLE_USER_ID="user-123"
```

All API calls must include two headers:

* `Authorization: Bearer <API_KEY>`
* `X-Envole-User-Id: <user-id>`

## 2. Start a session

Create a thread for your assistant. Replace placeholders with your real values.

```bash
curl -X POST \
  -H "Authorization: Bearer $ENVOLE_API_KEY" \
  -H "X-Envole-User-Id: $ENVOLE_USER_ID" \
  -H "Content-Type: application/json" \
  -d '{"agentId": "agent_123"}' \
  /api/assistants/threads
```

The response includes an `id` field representing the thread identifier used in subsequent calls.

## 3. Post a message and stream events

Messages are sent to the thread and responses are streamed back using [Server‑Sent Events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events). The request body now uses a `content` array where each item describes a piece of the message, such as text or files.

### TypeScript / JavaScript

```ts
const API_KEY = process.env.ENVOLE_API_KEY!;
const threadId = "YOUR_THREAD_ID";
const userId = process.env.ENVOLE_USER_ID!;

async function main() {
  // Send the user's message and stream back the assistant events
  const r = await fetch(`/api/assistants/threads/${threadId}/messages`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${API_KEY}`,
      "X-Envole-User-Id": userId,
    },
    body: JSON.stringify({
      content: [
        { type: "text", text: "Hi what can you do for me?" },
      ],
    }),
  });

if (!r.ok) {
    console.error("Request failed", await r.json());
    throw new Error(`Request failed ${r.status}`);
  }

const reader = r.body!.getReader();
  const decoder = new TextDecoder();
  let buffer: string[] = [];

try {
    while (true) {
      const { done, value } = await reader.read();
      if (done) break;

const chunk = decoder.decode(value);
      for (let i = 0; i < chunk.length; i++) {
        const ch = chunk[i];

if (ch !== "\n") {
          buffer.push(ch);
          continue;
        }

const line = buffer.join("").trimEnd();
        buffer = [];
        if (!line.startsWith("data:")) continue;

const data = JSON.parse(line.slice(5).trim());
        const { type, eventMessage } = data;

if (type === "AGENT_RESPONSE_CHUNK") {
          process.stdout.write(eventMessage.content ?? "");
        } else if (type === "AGENT_RESPONSE_COMPLETE") {
          console.log("\nDone");
        }
      }
    }
  } finally {
    reader.releaseLock();
  }
}

main().catch(console.error);
```

### Python

```py
import json
import os
import requests

API_KEY = os.environ["ENVOLE_API_KEY"]
thread_id = "YOUR_THREAD_ID"
user_id = os.environ["ENVOLE_USER_ID"]

def main() -> None:
    r = requests.post(
        f"/api/assistants/threads/{thread_id}/messages",
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "X-Envole-User-Id": user_id,
            "Content-Type": "application/json",
        },
        json={
            "content": [
                {"type": "text", "text": "Hi what can you do for me?"}
            ]
        }
    )
    r.raise_for_status()

buffer = ""
    for chunk in r.iter_content(decode_unicode=True):
        for ch in chunk:
            if ch != "\n":
                buffer += ch
                continue

line = buffer.rstrip()
            buffer = ""
            if not line.startswith("data:"):
                continue

data = json.loads(line[5:].strip())
            event_type = data["type"]
            message = data["eventMessage"].get("content", "")

if event_type == "AGENT_RESPONSE_CHUNK":
                print(message, end="")
            elif event_type == "AGENT_RESPONSE_COMPLETE":
                print("\nDone")

if __name__ == "__main__":
    main()
```

## 4. Understanding events

Each `data:` line is a complete `SseEvent` object:

```json
{
  "type": "AGENT_RESPONSE_CHUNK",
  "eventId": "evt_2",
  "threadId": "thread_456",
  "requestId": "req_1",
  "eventMessage": {
    "agent": null,
    "content": "Hello",
    "collaborationId": null,
    "activeAssistantCollaborationRequired": null,
    "toolExecutionApprovalRequest": null,
    "toolExecutionApprovalResponse": null,
    "timestamp": "2025-08-12T00:00:01"
  }
}
```

Events such as `AGENT_RESPONSE_CHUNK`, `AGENT_RESPONSE_COMPLETE`, `TOOL_EXECUTION_APPROVAL_REQUEST`, and the many `NOTIFICATION_*` types are documented in the [Streaming reference](/api-reference/streaming/index).

With these steps you can programmatically interact with your assistant and handle its streaming responses end‑to‑end.

***

## What's Next?

<Card title="Sub Assistant Nodes" icon="code" href="/sub-assistants/nodes/profiles">
  Learn how nodes define your sub-assistant's workflows
</Card>

# Deploy Your Assistant
Source: https://docs.envole.ai/sub-assistants/deploying-your-assistant/index

Get your assistant ready to go

## Testing/Running your assistant

Once you have completed building your assistant you can test it is working correctly by clicking the
`Run` button at the top right

This will run the workflow and your assistant should spring to life and prompt you to ask them a question

From here you can interact with the assistant as you would any other person.

And the assistant in term will respond in turn.
Now that you have tested and checked it is working as expected its time to get it published
so that you and others can start using it in a production setting

## Publishing your assistant

To begin the publishing process you can click the top right `Publish` button.

This will prompt us to enter a deployment message into the text box
and click the `Confirm` button to action the publishing process

Importantly the system validates that nothing is unconnected before publishing

And so if you have forgotten to connect u all your components the system will throw up an error
and tell you to go back and fix the problem, which ensures that only validated assistants make it to production.

Once we fix any errors we can try again as if all is well we will see the assistant being published

After this process is completed we can see that the assistant is now online
and that the version number has been incremented

Congratulations, your assistant has been successfully deployed
and now you and others will always have an assistant to help you with this specific task.

## Taking your assistant offline

Sometimes you may want to take an assistant offline, for example to do maintanance, etc.
This process is easy, simply hitt the toggle and the system will `deactive` the assistant

after which your assisant will now be offline.

## A note on versions

Importantly any changes you have made which are visible in the current state of the canvas below are always considered a draft version.
That means the current canvas, i.e. your current draft of the assistant is the thing which will be deployed when you click publish.

Deploying this draft will automatically version the new assistant as `v2` (or `v5` if `v4` was the last version, etc)

The currently deployed version is clearly indicated with the live label.

Showing you which version of the assistant is currently live and answering questions.

You may be wondering what happens to the old `v1` assistant when a new version is deployed, does it dissapear?
No, certainly not, it gets archived in history.
And you are able to see all of the versions of your assistants in the version section above the canvas as previously shown.

This means that at any point in time If you can roll-back and re-deploy an older version of the assistant.
all you need to do is click the older version you wish to re-deploy and click the preview button next to the version info.

This will cause a preview section to appear at the top of the canvas.

Clicking the "Replace draft with this version", will prompt you to confirm that you want to overwrite the canvas
i.e. your current unpublished changes and that you want to roll back to the older version.

Doing so will show a message and confirm that your canvas has been changed back to `v1`

You will note however that `v2` is still the version that is online.
That is because, as we mentioned before, the canvas is our current draft.
All we did was replace our current canvas with `v1`.
In order for the changes to take effect, i.e. in order to fully roll back `v1`
we must now publish our draft/the current canvas using the usual process

Lets give it a roll back comment, and confirm.

And thats it. We have successfully rolled back to `v1` and it is now live in production.

Note however that this is now `v3`. i.e. `v1` and `v3` are the same.
And that as always we can see the full deployment history of all version `v1`,`v2`,`v3`, and our current draft.

***

## What's Next?

<Card title="Interact with Your Assistant" icon="users" href="/sub-assistants/interacting-with-your-assistant">
  Learn how to use and manage your deployed assistant
</Card>

# External Integrations
Source: https://docs.envole.ai/sub-assistants/external-integrations/index

Guide to integrating sub-assistants across platforms

Sub-assistants are flexible workflow helpers that can be integrated into your team's favorite collaboration platforms. Their on-demand, user-driven design makes them perfect for automating targeted tasks across Slack, Teams, WhatsApp, and other environments. This guide covers key integration options for getting the most out of your sub-assistants in your team's daily work.

## Integration Capabilities

* **API Integration:** Sub-assistants can be integrated by API into custom tools, web apps, or other platforms as needed.
* **Chat Platform Integration:** Sub-assistants can be triggered in Slack, Microsoft Teams, and WhatsApp, but do not natively join meetings or take notes.
* **Workflow Automation:** Sub-assistants can be invoked via dashboard workflows, chat commands, or triggered by Team PAs as part of a larger workflow.
* **Sharing & Publishing:** Sub-assistants can be published for team-wide use or shared across teams for broader workflow automation.

## Usage Scenarios

* Integrate sub-assistants into Slack channels for quick, on-demand automation.
* Use API endpoints to automate sub-assistant workflows from external platforms.
* Share sub-assistants with other teams to standardize and streamline common processes.
* Combine sub-assistants with Team PAs for end-to-end workflow coverage.

## Best Practices

* Choose chat and API integrations that align with your team’s daily workflow.
* Share and publish effective sub-assistants to maximize impact across teams.
* Use sub-assistants to complement, not replace, the proactive orchestration of Team PAs.
* Iterate on sub-assistant automation as your team’s needs evolve.

Sub-assistants are flexible, on-demand workflow helpers that integrate with team chat and automation platforms for targeted productivity gains.

***

## What's Next?

<Card title="Sub-Assistant API Integration" icon="code" href="/sub-assistants/api-integration">
  Learn how to integrate sub-assistants programmatically
</Card>

# Build an assistant
Source: https://docs.envole.ai/sub-assistants/how-to-build-an-assistant/index

Lets begin the process of building your automated workflow

Building an assistant in Envole is like creating a comprehensive job description and work environment for a digital employee. You'll define their role, provide resources, and set up workflows just as you would for a new team member.

## Getting Started with the Workflow Editor

### Navigate to the Editor

To start building your assistant, find your way to the Workflows Editor:

* Click the `Create New Assistant` button on the Home tab, or
* Edit an existing workflow from the Assistants tab

### Understanding the Interface

Once you're in the editor, you'll see:

* **Top navigation**: Options to view Apps and Analytics
* **Toolbar** (top right): Run, Save, and Edit workflow controls
* **Left sidebar**: Components for building your workflow
* **Main canvas**: Where you'll build your assistant workflow

The left sidebar contains five types of components that work together to create your automated workflow:

* **Profile**: The core identity and job description
* **Inputs**: How information enters the workflow (e.g., customer questions)
* **Activities**: How you want the assistant to process information (e.g., analyze sentiment)
* **Tools**: External systems and integrations (e.g., email, CRM)
* **Outputs**: The final results delivered to users (e.g., formatted responses)

## Understanding How Components Work Together

Think of these components as different aspects of defining a complete work role:

**Profile** is your assistant's job description - it defines who they are, what they do, how they behave, and what they know.

**Inputs & Activities** are the implementation details - Inputs determine how work comes to your assistant, while Activities define the specific tasks they perform.

**Tools** are the external resources your assistant can access - email systems, databases, APIs, and other business applications.

**Outputs** define how your assistant presents their completed work - formatted responses, structured data, or other deliverables.

## Building Your Assistant Step-by-Step

### Step 1: Set Up Your Assistant's Identity (Profile)

The Profile is the foundation of your assistant. Start here to establish their core identity and enable collaboration with other assistants.

#### Fill in the Identity Fields

* **Agent Name**: Give your assistant a clear, recognizable name (e.g., "Customer Support Assistant", "Marketing Helper")
* **Role**: Define what job they perform (e.g., "Customer Service Representative", "Content Creator")
* **Agent Handle**: Create a unique handle like @support, @marketing, or @sales that allows users and other assistants to mention and collaborate with this assistant. This handle enables multi-assistant workflows where assistants can reference each other's expertise.

**Why handles matter**: When you create multiple assistants, they can work together by mentioning each other using their handles. For example, a customer service assistant (@support) might bring in a technical specialist (@tech) for complex issues, or a content creator (@marketing) might consult with a data analyst (@analytics) for campaign insights.

#### Write the Description

Define your assistant's personality and approach to work:

* Their expertise and responsibilities
* How they should communicate (formal/casual, brief/detailed)
* Their approach to problem-solving

**Example descriptions:**

* "You are a friendly customer support specialist who helps solve technical issues with patience and clear explanations"
* "You are a data analyst who provides accurate insights and explains complex findings in simple terms"

#### Set Goals and Constraints

**Goals** - What should your assistant accomplish:

* "Resolve customer issues quickly and professionally"
* "Create engaging content that drives user engagement"

**Constraints** - What they should NOT do:

* "Never share confidential customer information"
* "Escalate billing issues over \$500 to the finance team"
* "Always maintain a professional tone"

#### Configure Knowledge and Model Settings

* Turn on **Embed Knowledge** to connect to relevant knowledge bases
* Choose your **AI Provider** (OpenAI, Anthropic, Google)
* Select the appropriate **Model** for your needs
* Adjust **Creativity Level** from Focused to Experimental

### Step 2: Define How Information Enters (Inputs)

Inputs determine how users will interact with your assistant.

#### Choose Input Types

Select based on what information users need to provide:

* **Text Input**: For questions, instructions, or written content
* **File Input**: For document uploads (PDFs, Word docs, etc.)
* **URL Input**: For web links to analyze
* **Image Input**: For photos or images
* **Data Input**: For structured data like forms

#### Configure the Prompt

Write a clear description of what type of input you expect:

**Good prompts:**

* "Customer support questions or issues requiring assistance"
* "Resume documents for analysis"
* "Product images for description generation"

**Avoid vague prompts:**

* "Input"
* "Information"
* "Data"

### Step 3: Configure Processing Tasks (Activities)

Activities define the core work your assistant performs. You'll first choose from pre-configured activity types, then write prompts that guide HOW to perform each activity.

#### Choose Activity Types

Select from pre-configured options like:

* **Answer Questions**: Respond to user inquiries
* **Summarize Content**: Condense information into key points
* **Sentiment Analysis**: Analyze emotional tone in text
* **Write Emails**: Create email content based on context
* **Custom**: Define specialized tasks unique to your needs

#### Write Custom Prompts

Your prompts guide HOW the assistant should perform the chosen activity type:

**Example prompts:**

**Good prompt structure:**

* Start with action words: "Analyze", "Extract", "Generate", "Summarize"
* Be specific about requirements
* Include format guidelines
* Mention constraints

#### Choose Response Type

* **Text**: For natural language responses, explanations, summaries
* **Structured (JSON)**: For data extraction, categorization, consistent data format

When you select Structured, define JSON fields:

* **Field Name**: The key in your output (e.g., "priority", "category")
* **Description**: What this field should contain

#### Select the Right Model

* **GPT-4**: Best for complex reasoning and analysis
* **Claude**: Excellent for writing and communication
* **Gemini**: Good for general-purpose tasks

### Step 4: Connect External Tools (Tools)

Tools let your assistant take actions beyond processing information.

#### Select Your Tools

Choose based on what actions your assistant needs:

* **Email & Communication**: Gmail, Outlook, Teams
* **Project Management**: Asana, Linear, Monday.com
* **Customer Management**: HubSpot, Salesforce, Attio
* **Custom Integrations**: Your organization's systems

#### Set Up Authentication

* **API Key**: Enter your credentials for services using this method
* **OAuth**: Use secure flows for platforms like Gmail (no password sharing)
* **Custom**: Configure authentication for specialized systems

#### Configure Permissions

Choose the right permission level based on what the tool will do:

**Human Approval** - Recommended for actions that make changes to external systems:

* Sending emails or messages to customers
* Creating new records in CRM systems
* Updating customer data or profiles
* Creating tasks or projects in project management tools
* Making purchases or financial transactions
* Posting content to social media
* Deleting or modifying existing data

**Auto Execute** - Suitable for actions that only fetch or read data:

* Looking up customer information
* Searching knowledge bases
* Retrieving project status
* Checking inventory levels
* Reading email or message history
* Generating reports from existing data

**Why this matters**: Requiring human approval for data retrieval can significantly slow down user interactions and hurt the user experience. Users expect quick responses when asking for information, but they appreciate confirmation before the assistant takes actions that could affect external systems or data.

#### Add Custom Instructions

Define exactly how tools should behave:

**Example for Email Tool:**

```
When sending customer support emails:
- Include the ticket reference number in the subject
- Use our customer support signature template
- Copy the support manager on all emails
- Set priority to "High" for urgent issues
```

**Example for CRM Tool:**

```
When creating customer records:
- Always include lead source in the description
- Set follow-up reminder for 3 days
- Tag based on company size: startup, SMB, or enterprise
```

### Step 5: Format Your Outputs (Outputs)

Outputs define the format of results your assistant delivers. Simply choose the format and your assistant will respond accordingly.

#### Choose Output Format

* **Text**: For conversational responses, explanations, summaries, and natural language content
* **Structured (JSON)**: For data extraction, categorization, and information that needs further processing

## Adding and Connecting Components

### Adding Components

Simply click and drag any component from the left sidebar onto the main canvas. Each component represents a step in your workflow.

### Connecting Components

Connect components by dragging lines between them to create your workflow:

1. Information flows through Inputs
2. Gets processed by Activities
3. May use Tools for external actions
4. Results are delivered through Outputs
5. Everything operates within Profile guidelines

### Example Workflow

**Customer Support Assistant:**

* **Profile**: Helpful, professional customer service specialist
* **Input**: Customer inquiry via text
* **Activity**: Analyze issue and craft response
* **Tool**: Check customer history in CRM
* **Output**: Formatted email response

## Finalizing Your Workflow

### Test Your Assistant

Use the Run button to test your workflow with sample inputs:

* Try different types of questions or data
* Check that responses match your expectations
* Verify tool integrations work correctly
* Ensure outputs are properly formatted

### Save and Publish

Once your workflow produces the correct results:

1. **Save** your workflow using the toolbar
2. **Publish** it to make it available for use
3. Your assistant will now be accessible from the home page

## Best Practices Summary

### Start with a Clear Profile

* Be specific about your assistant's role and expertise
* Set clear boundaries and constraints
* Choose the right AI model for your needs

### Design User-Friendly Inputs

* Make it obvious what users should provide
* Use clear, specific prompts
* Choose input types that match how users naturally want to interact

### Write Effective Activity Prompts

* Be specific about what you want
* Include examples when helpful
* Break complex tasks into simpler steps

### Configure Tools Securely

* Use minimum necessary permissions
* Require human approval for actions that change external systems (mutations)
* Use auto-execute for data retrieval to maintain good user experience
* Write clear custom instructions

### Choose the Right Output Format

* Use **Text** for conversational responses and human-readable content
* Use **Structured (JSON)** when you need consistent data format for further processing

## What's Next?

After building your assistant, you'll want to:

1. **Deploy Your Assistant**: Learn how to make it available to users
2. **Interact with Your Assistant**: Understand how to use and manage your deployed assistant
3. **[Multi-Assistant Collaboration](https://docs.envole.ai/getting-started/multi-assistant-collaboration)**: Learn how to set up assistants that work together
4. **[API Integration](https://docs.envole.ai/getting-started/api-integration)**: Integrate your assistant with external systems and applications

Your assistant is now ready to help automate workflows and provide value to your users while maintaining the professional standards and constraints you've established.

# Interact With Your Assistant
Source: https://docs.envole.ai/sub-assistants/interacting-with-your-assistant/index

Stand back and let the assistant do the work

Once you have your assistant has been deployed you are ready to start asking it questions
and get it working for you, seamlessly automating previously time consuming tasks.

## Start a session your assistant

First we need to start a session with the assistant.
From the home tab you can click any of the assistants published by you, your team, or organisation to start a session with it

Once selected the centre screen will refelct your selection and you will be ready to start asking the assistant questions

Clicking the `Start New Working Session` button will drop you into a working session with the assistant

After asking a question

The assistant will respond with helpful suggestions to help you streamline your work.

Congratulations, you have intereacted with a live assistant.
From here you can ask more questions or favourite the session using the start icon
so that you can come back to this session later.

The right hand menu tab also has options to begin a new session (in case you want to start fresh)
as well as show you a history of the currently active session.

***

## What's Next?

<Card title="Multi-Assistant Collaboration" icon="users" href="/sub-assistants/multi-assistant-collaboration">
  Discover how assistants can collaborate on complex workflows
</Card>

# Multi-Assistant Collaboration
Source: https://docs.envole.ai/sub-assistants/multi-assistant-collaboration/index

Stand back and let the assistant do the work

Now that you've learned how to interact with a single assistant, let's explore one of Envole's most powerful features: getting multiple assistants to work together on complex tasks. When you need diverse expertise or want different perspectives on a challenge, you can bring multiple specialized assistants into the conversation with a simple @-mention.

## Why Use Multiple Assistants?

Sometimes a single assistant, no matter how capable, isn't enough. Maybe you're working on a product feature that needs both technical and marketing input, or you're tackling a customer issue that requires both support and sales perspectives. Instead of having separate conversations with different assistants, Envole lets you bring the right expertise together in one seamless collaboration.

The beauty of multi-assistant collaboration is that it happens automatically. You simply mention the assistants you want to involve, and Envole coordinates everything behind the scenes, ensuring you get comprehensive, well-rounded responses.

## How to Start a Collaboration

### Step 1: Find Available Assistants

When you're typing in the chat, simply type the @ symbol to see all the assistants available in your organization.

A dropdown will appear showing all the assistants you can collaborate with. Each assistant has a unique handle (like @sales\_enrichment, @product, @engineering) that makes it easy to identify their specialization.

### Step 2: Mention Multiple Assistants in Your Message

To start a collaboration, simply mention two or more assistants in your message. You can write naturally - there's no special syntax or complicated commands to remember.

In this example, the user is asking for help creating a Product Requirements Document (PRD) and mentions @sales\_enrichment to get input about marketing and sales widgets. You can write your request just like you would in a normal conversation, mentioning the assistants whose expertise you need.

### Step 3: Collaboration Begins Automatically

Once Envole detects that you've mentioned multiple assistants, it automatically initiates the collaboration process. You'll see a "Collaboration response complete" indicator, letting you know that the assistants are working together on your request.

During this phase, Envole is coordinating between the different assistants, ensuring they understand the context and can provide complementary insights. You don't need to do anything - just wait for the collaborative response.

### Step 4: Receive Your Collaborative Response

The result is a comprehensive response that combines the expertise of all the assistants you mentioned. You'll see which assistant contributed which parts of the response, giving you transparency into the collaboration.

In this example, @sales\_enrichment provides detailed information about marketing and sales widgets, including specific recommendations for pipeline tracking, communication sync, deal flagging, and performance dashboards. The response is thorough and actionable because it draws on the assistant's specialized knowledge.

After the specialized assistant provides their expertise, the main assistant you were originally interacting with often follows up to tie everything together and provide additional context or next steps.

This follow-up response from your primary assistant helps synthesize the collaborative input and ensures you have a complete, actionable path forward. The main assistant acts as a coordinator, making sure all the specialized knowledge comes together in a way that directly addresses your original request.

## Key Benefits of Multi-Assistant Collaboration

**Comprehensive Expertise**: Get insights from multiple specialized assistants in a single response, ensuring you don't miss important perspectives.

**Seamless Coordination**: Envole handles all the coordination automatically - you don't need to manage separate conversations or merge different responses yourself.

**Context Preservation**: All assistants understand the full context of your request, ensuring their responses work together rather than conflicting.

**Time Savings**: Instead of having multiple separate conversations, you get everything you need in one comprehensive response.

**Quality Improvement**: Multiple perspectives often lead to better solutions, catching potential issues or opportunities that a single viewpoint might miss.

## When to Use Multi-Assistant Collaboration

Multi-assistant collaboration is particularly valuable when:

* **Cross-functional projects**: When you need input from different departments or specializations (like product + engineering, or sales + marketing)

* **Complex problem-solving**: When a challenge requires multiple types of expertise to solve effectively

* **Comprehensive planning**: When you're creating documents, strategies, or plans that benefit from diverse perspectives

* **Risk assessment**: When you want multiple viewpoints to identify potential issues or opportunities

* **Learning and exploration**: When you're entering unfamiliar territory and want to understand different aspects of a topic

## Tips for Effective Collaboration

**Be specific about what you need**: The more context you provide, the better the assistants can tailor their collaborative response. Instead of "help me with this project," try "help me create a go-to-market strategy for our new feature."

**Choose the right assistants**: Think about what types of expertise your request requires. If you're working on a customer issue, you might want @support and @sales. For a technical project, consider @engineering and @product.

**Ask follow-up questions**: If the collaborative response raises new questions or you need deeper insight into specific areas, don't hesitate to continue the conversation or mention additional assistants.

**Use natural language**: There's no need for special commands or formatting. Write your requests as you would naturally speak, mentioning the assistants you want to involve.

## Getting the Most Value

The goal of multi-assistant collaboration isn't just to get more information - it's to get better information. By bringing together different perspectives, you're more likely to:

* Identify blind spots in your thinking
* Discover innovative solutions you hadn't considered
* Avoid potential pitfalls by getting diverse viewpoints
* Create more robust and well-rounded strategies

Remember, you're not just getting multiple answers to the same question - you're getting a coordinated response where each assistant contributes their unique expertise to create something more valuable than the sum of its parts.

## What's Next?

Now that you understand how to leverage multiple assistants working together, you're ready to tackle more complex challenges with confidence. Whether you're planning a product launch, solving a customer issue, or exploring new business opportunities, you have a team of specialized assistants ready to collaborate on your behalf.

As you become more comfortable with multi-assistant collaboration, you'll start to recognize patterns in which combinations of assistants work best for different types of tasks. This intuition will help you get even more value from the platform over time.

Ready to dive deeper into Envole's capabilities? Check out our [API Integration guide](https://docs.envole.ai/getting-started-section/api-integration) to learn how developers can build on these collaboration features.

# Activities
Source: https://docs.envole.ai/sub-assistants/nodes/activities/index

## What does it do?

Activities nodes define the core processing steps that your assistant performs. They contain the instructions and configuration that determine how your assistant processes inputs and generates outputs. Think of Activities as the "brain" of your workflow - where the actual work happens.

Activities take information from Input nodes and transform it according to your instructions and requirements.

## How do I use it?

### Setting Up an Activity Node

When you add an Activity node, you'll first choose from pre-configured activity types, then configure how your assistant should perform that specific activity:

#### Pre-Configured Activity Types

**Answer Questions**: Responds to user inquiries by analyzing the question and providing relevant answers

* *Prompt purpose*: Guide HOW to answer questions (tone, depth, sources to reference, format)
* *Example prompt*: "Answer customer questions in a friendly, professional tone. Always check the knowledge base first and escalate complex technical issues to @tech support."

**Summarize Content**: Condenses information into concise summaries while preserving key points

* *Prompt purpose*: Define HOW to summarize (length, focus areas, format, what to emphasize)
* *Example prompt*: "Create 3-4 bullet point summaries focusing on key business insights and actionable recommendations. Include relevant metrics when available."

**Sentiment Analysis**: Analyzes the emotional tone and sentiment in text content

* *Prompt purpose*: Define HOW to analyze sentiment and present findings
* *Example prompt*: "Analyze customer feedback for sentiment (positive, negative, neutral). Highlight key themes and provide actionable insights for improvement."

**Write Emails**: Creates email content based on context and requirements

* *Prompt purpose*: Specify tone, format, and style for email composition
* *Example prompt*: "Write professional customer service emails that are empathetic and solution-focused. Include clear next steps and appropriate sign-off."

**Custom**: Flexible activity type for specialized tasks unique to your needs

* *Prompt purpose*: Define any custom processing task and how it should be performed
* *Example prompt*: "Analyze product reviews and extract key feature mentions, rating trends, and improvement suggestions formatted as actionable insights."

#### Activity Configuration

After selecting your activity type, configure these components:

**Custom Prompt**: Instructions that guide HOW your assistant should perform the chosen activity type.

**Response Type**: Choose between text responses (natural language) or structured responses (JSON format).

**Model Selection**: Select which AI model should process this activity.

### Custom Prompt Configuration

Write clear, specific instructions that guide HOW your assistant should perform the selected activity type. Remember: the activity type defines WHAT to do, your prompt defines HOW to do it.

**Example prompts:**

* "Analyze the customer support ticket and categorize it as: technical, billing, general inquiry, or complaint. Provide a brief summary."
* "Extract the customer's name, email, order number, and issue description from this support message"
* "Generate a professional email response addressing the customer's concerns with an empathetic tone"
* "Summarize the key points from this document in 3-4 bullet points"

**Good prompt structure:**

* Start with action words: "Analyze", "Extract", "Generate", "Summarize"
* Be specific about what you want
* Include format requirements when needed
* Mention any constraints or guidelines

### Response Type Selection

**Text Response**:

* Natural language output
* Good for explanations, customer responses, reports, summaries
* Easy to read and understand

**Structured Response (JSON)**:

* Organized data format with defined fields
* Good for data extraction, categorization, form filling
* Requires you to define field names and descriptions

When you select "Structured", you'll add JSON fields:

* **Field Name**: The key in your output (e.g., "priority", "category", "summary")
* **Description**: What this field should contain

## Best Practices

### Write Clear Instructions

Be specific about what you want the assistant to do. Include examples when helpful.

**Good**: "Extract the customer's name, email, and order number from this support ticket"
**Poor**: "Process this customer message"

### Choose the Right Response Type

* Use **Text** for human-readable responses like emails, summaries, or explanations
* Use **Structured** when you need consistent data format for categorization or extraction

### Keep Activities Focused

Each Activity should handle one specific task. Break complex processes into multiple connected activities for better results.

### Test with Real Data

Use actual examples of the inputs you expect to receive to test and refine your prompts.

# Inputs
Source: https://docs.envole.ai/sub-assistants/nodes/inputs/index

## What does it do?

Input nodes define how users provide information to your assistant. They specify what type of data your assistant can receive and how that information should be processed. Think of Input nodes as the entry points where users submit their requests, documents, or data for your assistant to work with.

## How do I use it?

### Setting Up an Input Node

When you add an Input node to your workflow, you'll choose from several input types based on what kind of information users need to provide:

**Text Input**: For written requests, questions, or instructions from users
**File Input**: For document uploads (PDFs, Word docs, spreadsheets, etc.)
**URL Input**: For web links that your assistant should analyze or process
**Image Input**: For photos or images that need analysis or processing
**Data Input**: For structured data like forms or specific data formats

### Configuring the Input

Each Input node has one main configuration field:

**Prompt**: Describe what type of input you expect users to provide. This helps both users understand what to submit and guides your assistant in processing the information correctly.

For example:

* "Customer support questions or issues"
* "Resume documents for analysis"
* "Product images for description generation"
* "Website URLs for content analysis"

## Configuration Options

### Input Types Available

**Text Input**:

* Users type their request directly
* Good for questions, instructions, or written content
* Example prompt: "Customer service inquiries"

**File Input**:

* Users upload documents or files
* Supports common file formats (PDF, DOCX, images, etc.)
* Example prompt: "Contract documents for review"

**URL Input**:

* Users provide web links
* Assistant can access and analyze web content
* Example prompt: "Website URLs for SEO analysis"

**Image Input**:

* Users upload photos or images
* Good for visual analysis or processing
* Example prompt: "Product photos for catalog descriptions"

**Data Input**:

* Users provide structured data
* Good for forms or specific data formats
* Example prompt: "Sales data in CSV format"

### Custom Prompt Guidelines

Your prompt should clearly describe:

* What type of information you want
* Any specific format requirements
* The purpose or context for the input

**Good prompts**:

* "Customer support tickets or issues requiring assistance"
* "Legal contracts in PDF format for clause analysis"
* "Marketing campaign ideas and target audience details"

**Avoid vague prompts**:

* "Input"
* "Information"
* "Data"

## Best Practices

### Write Clear Prompts

Make it obvious to users what they should provide. Specific prompts lead to better input quality and more accurate processing.

### Match Input to Purpose

Choose the input type that best matches how users naturally want to provide information. Don't force users to upload files when they just want to type a question.

### Keep It Simple

Users should immediately understand what to provide without needing additional explanation or instructions.

### Test with Real Users

Try your input configuration with actual users to ensure it's intuitive and collects the information your assistant needs to be helpful.

# Outputs
Source: https://docs.envole.ai/sub-assistants/nodes/outputs/index

## What does it do?

Outputs nodes define how your assistant presents and delivers the results of their work to users. They control the formatting and delivery methods for everything your assistant produces - whether that's a conversational response or structured data.

Outputs are the final step in your assistant's workflow, ensuring that all the processing performed by Activity nodes is presented in a format that's useful and appropriate for your users.

## How do I use it?

### Selecting Output Formats

Choose between the two available output formats based on what users need:

**Text**: Written responses that can be formatted with headings, bullet points, and lists. Good for conversational interactions, explanations, and natural language content.

**Structured (JSON)**: Organized data in JSON format for users who need to perform further analysis or integrate with other systems. This provides consistent, machine-readable output with defined fields.

### Configuration Options

Choose the format that best fits your use case:

### Quality Standards

**Content Validation**: Ensure outputs are complete and accurate before delivery

**Format Consistency**: Maintain consistent style and presentation across all outputs

**User Experience**: Focus on making outputs easy to understand and act upon

## Best Practices

### Design for Your Users

Consider who will be reading the outputs and format them appropriately for that audience's technical level and information needs.

### Keep It Organized

Use clear headings, bullet points, and logical structure to make outputs easy to scan and understand.

### Maintain Quality Standards

Establish consistent formatting and presentation standards that reflect your organization's professionalism.

### Choose the Right Format

* Use **Text** for explanations, conversational interactions, and natural language content
* Use **Structured (JSON)** when you need consistent data format for extraction, categorization, or integration with other systems

### Test Different Formats

Try different output configurations to see what works best for your users and use cases.

# Profile
Source: https://docs.envole.ai/sub-assistants/nodes/profiles/index

## What does it do?

Profile nodes define the core identity and personality of your assistant. Think of the Profile as writing a job description for your digital employee - it establishes who they are, how they behave, and what they're responsible for.

The Profile acts as the foundation that all other nodes reference. It sets the overall personality, expertise, and boundaries for your assistant.

## How do I use it?

### Setting Up Your Assistant's Identity

Fill in these key fields to establish your assistant's core identity:

**Agent Name**: Give your assistant a clear, recognizable name that reflects their purpose (e.g., "Customer Support Assistant", "Sarah the Marketing Helper")

**Role**: Define what job this assistant performs (e.g., "Customer Service Representative", "Content Creator", "Data Analyst")

**Agent Handle**: Create a unique handle like @support, @marketing, or @sales that allows users and other assistants to mention and collaborate with this assistant. This handle enables multi-assistant workflows where assistants can reference each other's expertise.

**Collaboration Examples**:

* A customer service assistant (@support) can escalate technical issues to a specialist (@tech)
* A content creator (@marketing) can request data insights from an analyst (@analytics)
* A sales assistant (@sales) can get product details from a product expert (@product)

### Writing the Description

The description is where you define your assistant's personality and approach to work. Be specific about:

* Their expertise and responsibilities
* How they should communicate (formal/casual, brief/detailed)
* Their approach to problem-solving

**Example descriptions:**

### Setting Goals

Define what your assistant should accomplish:

**Examples:**

* "Resolve customer issues quickly and professionally"
* "Create engaging content that drives user engagement"
* "Provide accurate data analysis and actionable insights"

### Setting Constraints

Define what your assistant should NOT do or important boundaries to follow:

**Examples:**

* "Never share confidential customer information"
* "Escalate billing issues over \$500 to the finance team"
* "Always maintain a professional tone, even with frustrated customers"
* "Only provide information about our own products and services"

### Knowledge Base Integration

Turn on "Embed Knowledge" to connect your assistant to a knowledge base containing relevant information like:

* Product documentation
* Company policies
* FAQs and best practices

### Model Settings

**AI Provider**: Choose between OpenAI, Anthropic (Claude), or Google (Gemini)

**Model**: Select the specific model version based on your needs

**Creativity Level**: Adjust how creative vs. focused the responses should be:

* **Focused**: Precise and consistent responses
* **Balanced**: Good mix of creativity and reliability
* **Creative**: More varied and innovative responses
* **Experimental**: Highly creative but less predictable

## Best Practices

### Write Clear, Specific Descriptions

Be specific about what your assistant does and how they should behave. Avoid vague descriptions like "helpful assistant."

### Set Clear Boundaries

Use constraints to define what your assistant should never do or when they should escalate to humans.

### Choose the Right Model

* Use more powerful models (GPT-4, Claude Sonnet) for complex reasoning tasks
* Use faster models for simple tasks

### Test Your Configuration

Try different creativity levels and refine your description based on how your assistant performs in real conversations.

# Tools
Source: https://docs.envole.ai/sub-assistants/nodes/tools/index

## What does it do?

Tools nodes connect your assistant to external systems and services, giving it the ability to take actions beyond just processing information. Tools let your assistant send emails, update databases, create documents, and interact with business applications.

Think of Tools as giving your digital assistant access to the same software and systems that human employees use to get work done.

## How do I use it?

### Selecting Tools

Choose tools based on what actions your assistant needs to perform:

**Email & Communication**: Gmail, Outlook, Microsoft Teams for sending emails and messages

**Project Management**: Asana, Linear, Monday.com, ClickUp for creating tasks and updating projects

**Customer Management**: HubSpot, Salesforce, Attio for managing customer data and interactions

**Document & Content**: Tools for creating documents, presentations, and managing files

**Data & Analytics**: Database connections and spreadsheet tools for handling structured data

**Custom Integrations**: Connect to your organization's proprietary systems and APIs

### Setting Up Authentication

Most tools require credentials to access external systems:

**API Key**: Enter your API key for services that use this authentication method

**OAuth**: Use secure OAuth flows for platforms like Gmail and HubSpot - these don't require sharing passwords

**Custom**: Configure authentication for specialized or proprietary systems

All credentials are securely stored and encrypted.

### Configuring Tool Permissions

**Human Approval vs Auto Execute**:

* **Human Approval**: Assistant asks for permission before using the tool (recommended for sensitive actions like sending emails)
* **Auto Execute**: Assistant uses the tool automatically (good for internal data updates)

**Scope Limitations**: Define what the tool can access and modify in external systems

### Custom Instructions

Custom instructions let you specify exactly how tools should behave for your specific needs:

**Example for Email Tool:**

**Example for CRM Tool:**

```
When creating customer records:
- Always include lead source in the description
- Set follow-up reminder for 3 days
- Tag based on company size: startup, SMB, or enterprise
```

**Writing Good Custom Instructions:**

* Be specific about what the tool should do
* Include required fields or formatting
* Specify any approval processes
* Define error handling steps

### Referencing Activities

In custom instructions, you can reference Activity nodes using @activity-name to include their outputs or context in tool usage.

## Configuration Steps

1. **Select Your Tool**: Choose from available integrations or add a custom one
2. **Add Credentials**: Authenticate using API key, OAuth, or custom method
3. **Choose Actions**: Select which specific actions the tool can perform
4. **Set Permissions**: Decide if actions need human approval or can run automatically
5. **Add Custom Instructions**: Define exactly how the tool should behave (optional but recommended)

## Best Practices

### Security First

* Use the minimum permissions needed for each tool
* Require human approval for sensitive actions like external communications
* Regularly review which tools have access to what systems

### Write Clear Custom Instructions

Be specific about what you want the tool to do. Include examples when helpful.

**Good**: "Create a task in the 'Customer Support' project with priority set to 'High' and assign to the support manager"
**Poor**: "Create a task for this issue"

### Test Your Tools

Test tool configurations with sample data to make sure they work as expected before deploying to users.

### Start Simple

Begin with basic tool usage and add custom instructions as you understand your needs better.

# Team Personal Assistants
Source: https://docs.envole.ai/team-personal-assistants/index

Integration Guide

Team Personal Assistants integrate deeply into your team’s daily operations. They go far beyond basic chatbots—serving as integrated, always-on orchestrators across meetings, email, chat, and workflow tools. With advanced integration capabilities, your PA is present wherever your team collaborates: joining meetings to capture notes and action items, participating in email conversations with a dedicated mailbox for each member, and being available as a bot in Slack, Teams, WhatsApp, and in your workflow dashboard. This ensures your PA is always available, always context-aware, and always ready to coordinate work across platforms.

## Integration Capabilities

* **Meetings Integration:** Team PAs integrate with Zoom, Google Meet, Microsoft Teams, and Slack meetings. They join as a participant, take notes, flag action items, and generate summaries.
* **Dedicated Mailbox:** Each PA comes with a dedicated mailbox per team member. You can CC the PA into email threads, forward emails directly to it, or grant mailbox access for deeper insights and context extraction.
* **Chat Platform Integration:** PAs can act as bots in Slack, Microsoft Teams, and WhatsApp. You can interact with them via direct mentions or commands.
* **Dashboard Chat:** PAs are always accessible via a persistent chat sidebar in your dashboard workspace.
* **Cross-Platform Presence:** PAs can be mentioned by other PAs (@product, @sales, etc.), making them natively cross-functional across your organization.

## Usage Scenarios

* Integrate your PA into critical meetings for automatic note-taking and follow-up actions.
* Include your PA in important email threads to ensure all context is captured and summarized.
* Leverage chat integrations to interact with your PA from anywhere your team communicates.
* Use @mentions to connect with other PAs and orchestrate cross-team collaboration.

## Best Practices

* Integrate your PA with every major workflow—meetings, chat, and email—to maximize its value.
* Encourage team members to CC the PA in relevant email conversations.
* Leverage the dashboard chat for on-the-fly questions, insights, and orchestration.
* Regularly review integration points to ensure your PA is present where your team works.

With these integrations, your Team Personal Assistant becomes a true hub for team coordination and productivity.

***

## What's Next?

<CardGroup cols={3}>
  <Card title="Product & Engineering PA" icon="users" href="/team-personal-assistants/product-engineering">
    Dive into how PAs streamline product and engineering workflows
  </Card>

<Card title="Sales PA (Coming Soon)" icon="users" href="/team-personal-assistants/sales">
    Stay tuned for sales-specific PA capabilities
  </Card>

<Card title="Marketing PA (Coming Soon)" icon="users" href="/team-personal-assistants/marketing">
    Discover upcoming marketing-focused PA features
  </Card>
</CardGroup>

# Marketing PA
Source: https://docs.envole.ai/team-personal-assistants/marketing/index

Sub Assistants help your team automate granular work

## Coming Soon

The Marketing Personal Assistant is coming soon. Stay tuned for updates as we build dedicated capabilities for marketing teams.

***

## What's Next?

<Card title="Build an Assistant" icon="users" href="/sub-assistants/how-to-build-an-assistant">
  Learn how to create your own sub-assistant
</Card>

# Product and Engineering PA
Source: https://docs.envole.ai/team-personal-assistants/product-engineering/index

Sub Assistants help your team automate granular work

Your Team Personal Assistant (PA) is like a real-life PA dedicated to keeping your product and engineering teams organized, informed, and moving forward—without the chaos of context switching, status hunting, or scattered tools. Each team gets its own PA that connects directly to the tools and knowledge sources you already use, like Jira, Slack, Notion, GitHub, Linear, and Confluence.

#### What does a Team PA do for Product & Engineering?

* Brings together updates, tasks, technical docs, and action items from all your critical tools and channels—reducing time spent searching for context or duplicating updates.
* Surfaces technical blockers, pending pull requests, upcoming releases, and the latest specs or design docs, tied to the right projects and squads.
* Proactively generates meeting agendas for standups, sprint reviews, or planning sessions based on recent activity, ensuring every meeting is focused on current priorities and open issues.
* Keeps product and engineering systems in sync by letting you push or update tickets, tasks, and specs across Jira, Linear, GitHub, Notion, and Confluence in one step.
* Flags dependencies, risks, and cross-team blockers before they impact velocity, so leaders and ICs can act before issues escalate.

#### Widget-by-Widget Breakdown

**Daily Summary**

* **What it does:** Presents a tailored snapshot for your team: code review blockers, open PRs, release highlights, and unresolved dependencies.
* **How it helps:** Prioritizes your day around engineering and product realities, with actionable nudges to keep squads delivering.

**Goals & Projects**

* **What it does:** Showcases all active product goals and engineering projects, with status indicators, velocity metrics, and progress bars.
* **How it helps:** Lets you zoom in on risky sprints, see which features are on track, and align everyone on what’s shipping next.

**Upcoming Meetings**

* **What it does:** Lists all scheduled standups, sprint reviews, and planning sessions—each with a PA-generated agenda based on open blockers, ticket statuses, or recent team discussions.
* **How it helps:** Keeps meetings relevant to what’s happening in the repo, backlog, or roadmap, so every session leads to clear action.

**Tasks**

* **What it does:** Gathers engineering and product action items from standups, pull requests, Slack, or emails. Tasks can be instantly synced into tracking tools like Jira, Linear, or GitHub.
* **How it helps:** Removes manual status updates, keeps everything actionable, and syncs cross-system so engineers and PMs always work from the same list.

**Documents**

* **What it does:** Surfaces technical docs, API specs, PRDs, or design files created from meetings, Slack, or code discussions. Collaborate on drafts, then push the latest doc to Notion, Confluence, or your repo.
* **How it helps:** Makes sure the latest requirements, specs, and reference docs are always available and versioned—no more out-of-date files or lost threads.

**Latest Meeting Reports**

* **What it does:** Summarizes decisions and action items from engineering and product meetings, linking directly to related tickets, docs, or code branches.
* **How it helps:** Ensures follow-ups are visible, traceable, and acted on, with all context from the original meeting preserved.

**Milestones**

* **What it does:** Lists all upcoming releases, major deliverables, and deadlines, with status and risk signals.
* **How it helps:** Provides early warning for delayed or at-risk launches, so squads can focus resources and communicate proactively.

**Latest Insights**

* **What it does:** Surfaces trends in code review throughput, bug rates, team health, and collaboration analytics, all sourced from your engineering systems.
* **How it helps:** Enables the team to act on bottlenecks, optimize delivery, and see the impact of workflow improvements in real time.

***

**Always-on, always accessible:**
Your Team PA is continuously available as a chat on the right side of your workspace. Ask for updates, request insights, or collaborate with your PA at any time—right where you work.

***

## What's Next?

<CardGroup cols={2}>
  <Card title="Sales PA (Coming Soon)" icon="users" href="/team-personal-assistants/sales">
    Stay tuned for sales-specific PA capabilities
  </Card>

<Card title="Marketing PA (Coming Soon)" icon="users" href="/team-personal-assistants/marketing">
    Discover upcoming marketing-focused PA features
  </Card>
</CardGroup>

# Sales PA
Source: https://docs.envole.ai/team-personal-assistants/sales/index

Sub Assistants help your team automate granular work

## Coming Soon

The Sales Personal Assistant is coming soon. Check back soon for tools tailored to accelerate your sales workflows.

***

## What's Next?

<Card title="Explore the Marketing PA" icon="users" href="/team-personal-assistants/marketing">
  Discover upcoming marketing-focused PA features
</Card>

{batch.title}

Stopping: {tool.toolName}