Phone Call Skill

An intelligent AI skill that manages the complete phone call workflow: creating agents, executing calls, analyzing conversations, and providing actionable insights.

🚀 Quick Usage

For AI Agents calling this skill:

# Single command to make a complete phone call:
scripts/phone_call.sh \
  --to "+16576102352" \
  --purpose "Make dinner reservation for 2 people tonight at 8 PM. Name: John Smith"

What it does:

✅ Creates optimized AI agent
✅ Makes the phone call
✅ Waits for completion
✅ Analyzes conversation
✅ Reports success/failure with recommendations

Output: Clear success/failure report with extracted information.

Core Capabilities

This skill provides complete phone call management:

✅ Agent Creation - Create purpose-specific AI phone agents
✅ Call Execution - Initiate and monitor phone calls
✅ Conversation Analysis - Analyze call transcripts and extract key information
✅ Intelligent Reporting - Provide clear, actionable summaries to users
✅ Continuous Optimization - Learn from failures and improve agent performance

When to Use This Skill

Use this skill when the user wants to:

Make a phone call to someone (restaurant, customer, vendor, etc.)
Create an automated phone agent for specific tasks
Conduct batch phone calls
Have an AI agent communicate via phone
Analyze call transcripts and extract insights
Get intelligent summaries of phone conversations

Quick Start - For AI Agents

Simple Usage:

# Navigate to skill directory
cd ~/.openclaw/workspace/skills/phone-call

# Make a call (automatic agent creation)
./scripts/phone_call.sh \
  --to "+1234567890" \
  --purpose "Make a dinner reservation for 2 people tonight at 8 PM"

# Analyze results
./scripts/phone_call.sh --analyze "call-id-xxx"

The script handles everything:

Creates optimized agent based on purpose
Makes the phone call
Waits for completion
Analyzes and reports results

For advanced usage, see "Complete Workflow" below.

Complete Workflow

1. Understand User Intent & Gather Information

When the user requests a phone call, extract and confirm:

Required Information:

Phone number: Target contact (with country code)
Call objective: Specific goal (e.g., "book table for 2 at 8 PM", "confirm meeting")
Key details: All information needed to complete the task
Language: Language preference
Urgency: Time sensitivity

Example User Requests:

"Call +1-657-610-2352 to book a table for 2 people tonight at 8 PM"
"Make a reservation at this restaurant for dinner"
"Call the client to confirm tomorrow's 3 PM meeting"

What YOU Must Do:

Extract ALL required information from the user
Ask for missing details before proceeding
Confirm the complete task objective

2. Create Intelligent Phone Agent

Create an agent optimized for the specific task with proper safeguards.

📚 IMPORTANT: Read BEST_PRACTICES.md for detailed guidance on creating effective agents!

The most common failure mode is identity confusion - especially for outbound calls. The agent must understand:

WHO is calling WHOM (YOU are calling THEM for outbound calls)
What NOT to say (e.g., NEVER say "How can I help you?" on outbound calls)
Specific conversation flow (not vague objectives)

Agent Configuration Requirements:

Clear objective: Explicit instructions on what to accomplish
Task completion criteria: Agent must know when the task is done
Failure handling: What to do if the task cannot be completed
Timeout settings: Appropriate idle_time and call_duration
Conversation safeguards: "DO NOT hang up until task is confirmed complete"

Key Settings:

{
  "prompt": "Clear, step-by-step instructions + completion criteria",
  "idle_time_seconds": 15,
  "endpointing_sensitivity": "relaxed",
  "ask_if_human_present_on_idle": true,
  "noise_suppression": true,
  "conversation_speed": 1.0
}

3. Execute Call & Monitor

Initiate the call and track its progress.

What YOU Must Do:

Make the call using fluents.ai API
Wait for call to complete (don't interrupt mid-call)
Monitor for premature disconnections
Note the call duration and status

Warning Signs to Watch For:

⚠️ Call ends in < 30 seconds (likely failed)
⚠️ No conversation detected
⚠️ Status: human_disconnected too quickly

4. Analyze Call Results

CRITICAL: You MUST analyze every call to determine success/failure.

Use the analysis script:

python scripts/analyze_call.py --call-id "call_xxx"

Required Analysis:

Task Completion Check:
- ✅ Was the objective achieved? (e.g., reservation confirmed?)
- ❌ If not, why did it fail?
Conversation Quality:
- Did the AI say everything it needed to say?
- Did the other party respond?
- Was information exchanged properly?
Failure Pattern Detection:
- Too short (< 30 seconds) = likely early hangup
- One-sided conversation = recognition or response issue
- No confirmation = incomplete task execution
Extract Key Information:
- Confirmation numbers
- Alternative times/dates offered
- Reasons for rejection/failure
- Any action items

5. Provide Intelligent Report to User

CRITICAL: Always give the user a clear, actionable summary.

Your Report Must Include:

✅ Success Report Format:

✅ Task Completed Successfully!

Reservation Details:
- Restaurant: [Name]
- Date: Tonight
- Time: 8:00 PM
- Party size: 2 people
- Name: John Smith
- Confirmation: [if provided]

Call Duration: 1m 45s

❌ Failure Report Format:

❌ Task Failed - [Reason]

What Happened:
- Call duration: 15 seconds
- Issue: Restaurant hung up immediately
- Transcript: [show what was said]

Root Cause Analysis:
- [Specific problem identified]

Recommended Actions:
1. [Specific next step]
2. [Alternative approach]
3. [When to retry]

📊 Always Include:

Clear success/failure indicator
What was accomplished (or not)
Key information extracted
Next steps or action items
Whether retry is recommended

6. Optimize & Learn

After each call, identify improvements:

If Call Failed:

Analyze WHY it failed
Suggest agent improvements
Recommend retry timing
Consider alternative approaches

If Call Succeeded:

Note what worked well
Can the agent be more efficient?
What patterns led to success?

Common Optimizations:

Adjust idle_time for better patience
Improve prompt clarity
Add noise suppression
Modify conversation speed
Change voice or tone
Add retry logic with delays

Environment Setup

1. Install Dependencies

pip install -r requirements.txt

2. Configure API Keys

Create a .env file:

FLUENTS_API_KEY=your_api_key_here
FLUENTS_API_URL=https://api.fluents.ai
WEBHOOK_URL=https://your-webhook.com/callback

3. Test Connection

python scripts/test_connection.py

API Documentation

For detailed fluents.ai API documentation, see:

references/fluents_api.md - Complete API documentation
references/examples.md - Usage examples

Security Considerations

Privacy Protection: Ensure you have permission to call the target number
Compliance: Follow local telemarketing and anti-harassment regulations
Key Security: Never commit API keys to version control
Log Management: Properly manage call records with attention to data security

Usage Examples

Example 1: Simple Call

User: "Call 13800138000 to confirm tomorrow's 3 PM meeting"

Claude will:

Identify the phone call intent
Extract information (number: 13800138000, purpose: confirm meeting)
Create agent and set conversation script
Make the call
Wait for call completion
Return result: "Called 13800138000, they confirmed attendance at tomorrow's 3 PM meeting"

Example 2: Complex Conversation

User: "Call the customer to gather product feedback"

Claude will:

Ask for customer's phone number
Create agent with open-ended conversation capabilities
Set conversation guidelines (ask about product experience, collect feedback)
Make the call and conduct conversation
AI analyzes conversation content
Provide structured feedback report

Troubleshooting

Issue: Cannot connect to fluents.ai API

Check if API key is correct
Verify network connection
Check API service status

Issue: Call not answered

Confirm phone number format is correct (including country code)
Check if recipient is in service area
Review call logs for details

Issue: Speech recognition inaccurate

Check if language settings are correct
Adjust voice clarity parameters
Consider environmental noise factors

Technical Support

fluents.ai website: https://fluents.ai
API documentation: See references/ directory
Report issues: Submit a GitHub Issue

License

MIT License - See LICENSE file for details