# RevCent MCP Operation: `CreateAIVoiceAgent`

This document explains the `CreateAIVoiceAgent` MCP operation and how to create AI Voice Agents that can accept inbound calls or make outbound calls.

Sources:
- RevCent MCP schema for `CreateAIVoiceAgent`
- RevCent KB: `https://kb.revcent.com/tools/ai/voice-agents`
- RevCent AI Voice Agent Overview — `https://revcent.com/documentation/markdown/mcp/operation/OverviewAIVoiceAgent.md`

---

---

# Read the AI Voice Agent Overview First

Before creating, editing, triggering, or deeply configuring AI Voice Agents, MCP/AI should read the AI Voice Agent overview:

```text
https://revcent.com/documentation/markdown/mcp/operation/OverviewAIVoiceAgent.md
```

The overview explains AI Voice Agents as a whole, including:

```text
What AI Voice Agents are.
How inbound and outbound AI Voice Agents work.
Required AI and voice third-party integrations.
Realtime AI model and phone integration requirements.
Instruction design.
System actions.
Inbound caller matching.
Outbound triggers.
On-demand triggering.
Account-event triggering.
Filter Functions.
Pre-agent Functions.
Compiled call input data.
Handlebars usage.
AI Voice Snippets.
Call limits.
Active windows.
Customer-experience considerations.
Delay strategy.
Safety, compliance, and best practices.
```

This operation file is focused on the specific API/MCP operation. The overview provides the broader conceptual context MCP/AI should understand before making design decisions about an AI Voice Agent.

## Operation Summary

`CreateAIVoiceAgent` creates a new AI Voice Agent and returns a 20-character `ai_voice_agent_id`.

An AI Voice Agent requires two separate third-party integrations before it can work: an `ai` realtime third-party integration for the realtime AI model, and an `ai_voice` third-party integration for voice/phone calls. In the current supported configuration, the realtime `ai` integration is OpenAI using a `gpt-realtime-*` model, and the `ai_voice` integration is Twilio with a selected phone number. The agent also uses markdown instructions, optional Handlebars dynamic content, optional pre-agent Function data, optional outbound triggers, and opt-in system actions the AI may call during a live conversation.

---

# Critical Requirement: Required Third-Party Integrations

An AI Voice Agent cannot work unless **both** required third-party integrations already exist and are correctly configured.

The MCP must verify the required integrations before calling `CreateAIVoiceAgent`.

Required integrations:

| Required Integration | RevCent Integration Type | Current Supported Provider | Used By Field | Purpose |
|---|---|---|---|---|
| Realtime AI model integration | `ai` | OpenAI with `gpt-realtime-*` model | `third_party_integration_ai` | Powers the realtime AI conversation. |
| Voice / phone integration | `ai_voice` | Twilio with selected phone number | `third_party_integration_voice` | Handles inbound/outbound phone calls. |

Both are critical and required.

If either integration is missing, the MCP should not proceed directly to `CreateAIVoiceAgent`. It should first create the missing integration or guide the user through creating it.

---

## MCP Preflight Workflow for Required Integrations

Before creating an AI Voice Agent, the MCP should perform this workflow:

1. Call `GetUserThirdPartyIntegrations`.
2. Check whether a configured user third-party integration exists for type `ai`.
3. Confirm the `ai` integration is a realtime AI integration suitable for AI Voice Agents, currently OpenAI with a `gpt-realtime-*` model.
4. Check whether a configured user third-party integration exists for type `ai_voice`.
5. Confirm the `ai_voice` integration is a voice/phone integration suitable for AI Voice Agents, currently Twilio with a selected phone number.
6. If both exist, use their IDs:
   - `third_party_integration_ai`
   - `third_party_integration_voice`
7. If either is missing, create the missing integration before creating the AI Voice Agent.
8. Only call `CreateAIVoiceAgent` after both required integration IDs are available.

---

## If the Realtime `ai` Integration Is Missing

If no compatible realtime `ai` integration exists, the MCP should create one before creating the AI Voice Agent.

Recommended workflow:

1. Use `GetSiteThirdPartyIntegrations` to find the supported site integration for the realtime AI provider.
2. Use `GetSiteThirdPartyIntegration` to inspect required fields and options.
3. If credentials or secrets are required, use `CreateSecureForm` so the user can submit sensitive values securely.
4. After the user completes the secure form, call `CreateUserThirdPartyIntegration`.
5. If the integration requires account-specific options, retrieve it with `GetUserThirdPartyIntegration` and edit it with `EditUserThirdPartyIntegration` if needed.
6. Confirm the integration is configured with a realtime model, currently `gpt-realtime-*`.
7. Use the resulting user third-party integration ID as `third_party_integration_ai`.

Important:

- Do not guess or fabricate AI provider credentials.
- Do not ask the user to paste secrets directly into chat if a secure form is available.
- Do not proceed to `CreateAIVoiceAgent` until the realtime `ai` integration exists.

---

## If the `ai_voice` Integration Is Missing

If no compatible `ai_voice` integration exists, the MCP should create one before creating the AI Voice Agent.

Recommended workflow:

1. Use `GetSiteThirdPartyIntegrations` to find the supported site integration for voice/phone calls.
2. Use `GetSiteThirdPartyIntegration` to inspect required fields and options.
3. If credentials or secrets are required, use `CreateSecureForm` so the user can submit sensitive values securely.
4. After the user completes the secure form, call `CreateUserThirdPartyIntegration`.
5. If the integration requires selecting a phone number or account-specific option, retrieve it with `GetUserThirdPartyIntegration` and edit it with `EditUserThirdPartyIntegration` if needed.
6. Confirm the integration is configured for AI Voice Agent calling, currently Twilio with a selected phone number.
7. Use the resulting user third-party integration ID as `third_party_integration_voice`.

Important:

- The `ai_voice` integration is not optional.
- A voice integration without a selected/usable phone number is not sufficient.
- Do not proceed to `CreateAIVoiceAgent` until the `ai_voice` integration exists.

---

## Do Not Confuse the Two Integration Fields

The two fields are different and both must be supplied.

```json
{
  "third_party_integration_ai": "OPENAI_REALTIME_USER_INTEGRATION_ID",
  "third_party_integration_voice": "TWILIO_AI_VOICE_USER_INTEGRATION_ID"
}
```

Do not put the Twilio integration ID into `third_party_integration_ai`.

Do not put the OpenAI realtime integration ID into `third_party_integration_voice`.

Incorrect:

```json
{
  "third_party_integration_ai": "TWILIO_INTEGRATION_ID",
  "third_party_integration_voice": "OPENAI_INTEGRATION_ID"
}
```

Correct:

```json
{
  "third_party_integration_ai": "OPENAI_REALTIME_INTEGRATION_ID",
  "third_party_integration_voice": "TWILIO_AI_VOICE_INTEGRATION_ID"
}
```

---

## Integration Preflight Checklist

Before calling `CreateAIVoiceAgent`, confirm:

0. Confirm the AI Voice Agent overview has been reviewed when making broader design decisions.

1. A user third-party integration of type `ai` exists.
2. The `ai` integration is configured for realtime AI Voice Agent use.
3. The `ai` integration uses a supported realtime model, currently `gpt-realtime-*`.
4. A user third-party integration of type `ai_voice` exists.
5. The `ai_voice` integration is configured for voice/phone calling.
6. The `ai_voice` integration has a selected/usable phone number.
7. The MCP has the correct 20-character user integration ID for `third_party_integration_ai`.
8. The MCP has the correct 20-character user integration ID for `third_party_integration_voice`.
9. Any missing integrations have been created before attempting to create the AI Voice Agent.


# Critical Requirement: Do Not Use Minimal Agent Instructions

AI Voice Agent instructions are the most important and critical part of an AI Voice Agent.

The MCP should **never** create an AI Voice Agent using minimal, generic, placeholder, or example-only instructions such as:

```markdown
# Role & Objective
- You are a customer service agent.

# Conversation Flow
- Greet the caller.
- Help the caller.
- End the call.
```

That kind of minimal instruction is not sufficient for a production or test AI Voice Agent because the AI Voice Agent will speak directly with customers or prospects. Poorly specified instructions can cause the agent to:

- Say the wrong thing.
- Use the wrong tone.
- Ask for unnecessary information.
- Fail to verify the caller.
- Misuse system actions.
- Process payments or refunds incorrectly.
- Miss required compliance language.
- Call customers at the wrong time.
- Fail to transfer or end calls correctly.
- Produce a bad customer experience.

The MCP should treat the instructions as the core product being designed, not as a simple required field.

---

## Required MCP Behavior Before Creating an AI Voice Agent

Before calling `CreateAIVoiceAgent`, the MCP should gather enough information to write detailed, specific, accurate agent instructions.

If the user has not provided enough detail, the MCP should ask targeted questions before generating the final request.

The MCP should ask about:

| Area | What to Clarify |
|---|---|
| Agent purpose | What exact job should the voice agent perform? |
| Call method | Is the agent inbound or outbound? |
| Audience | Who will the agent speak to: customers, prospects, leads, existing subscribers, declined-sale customers, refund requesters, etc.? |
| Trigger | For outbound agents, is the trigger on-demand or account-event based? |
| Trigger item | What item type is the call about: customer, sale, shipping, subscription, renewal, trial, transaction, chargeback, fraud detection, etc.? |
| Business context | What product, campaign, brand, store, or offer is involved? |
| Success outcome | What should count as a successful call? |
| Conversation flow | What should the agent do first, second, third, and last? |
| Verification | What must the agent verify before discussing account details or taking action? |
| Allowed actions | Which system actions may the AI use during the call? |
| Prohibited actions | What should the AI never do? |
| Payment behavior | Can the agent collect a card, add a card, process a pending sale, or create a sale? What decline reasons should block same-card retry? |
| Refund behavior | Can the agent issue refunds? If yes, under what rules? |
| Transfer behavior | When should the agent transfer, and to what phone number? |
| End-call behavior | When should the agent end the call? |
| Tone | Friendly, professional, sales-focused, support-focused, empathetic, concise, etc. |
| Language | English only or other language rules. |
| Escalation | What should happen if the caller is angry, confused, asks for a human, or threatens a chargeback? |
| Compliance | Required legal, consent, recording, payment, or refund language. |
| Metadata | Should the agent insert call outcome metadata? If yes, what names and values? |
| Email follow-up | Should the agent send an Email Template after the call? |
| Function usage | Does the agent need filter Functions, pre-agent Functions, live-call `TriggerFunction` behavior, or decline-reason filtering before outbound calls? |
| Testing limits | Should the agent start disabled, limited by campaign, or limited by call count? |

---

## Required MCP Review Step

Before creating the AI Voice Agent, the MCP should display the drafted `settings.instructions.markdown` to the user for review.

The MCP should explicitly ask the user to review and approve or revise the instructions before calling `CreateAIVoiceAgent`.

Recommended review message:

```text
Below are the proposed AI Voice Agent instructions. Please review them carefully. These instructions control what the AI says, when it uses system actions, when it transfers, when it ends the call, and what it is not allowed to do. Tell me any changes before I create the AI Voice Agent.
```

The MCP should not create the AI Voice Agent until the user has had a chance to review the drafted instructions, unless the user explicitly instructs the MCP to proceed without review.

---

## Instruction Generation Standard

The MCP-generated instructions should be:

- Specific to the user’s stated use case.
- Written in structured Markdown.
- Detailed enough for a live customer-facing call.
- Explicit about when the AI should and should not use system actions.
- Explicit about when the AI should verify the caller.
- Explicit about what the AI should not say or do.
- Explicit about transfer and end-call behavior.
- Explicit about payment/refund/subscription behavior when relevant.
- Explicit about hard-decline reasons where the agent should not retry the same card or may skip the outbound call entirely.
- Personalized with Handlebars only when the relevant input data is available.
- Consistent with the selected `call_method`, outbound trigger, and enabled system actions.

The MCP should avoid generic instructions and instead write instructions around the user’s actual intended workflow.

---

## Recommended Instruction Structure

Use a structure like this as the starting point, then customize every section to the user’s specific use case:

```markdown
# Role & Objective
- Define exactly who the agent is and what outcome it is trying to achieve.

# Call Context
- Explain why this call is happening.
- Use Handlebars data when available.

# Personality & Tone
- Define tone, pacing, and language rules.

# Safety & Boundaries
- Define what the agent must never do.

# Verification Rules
- Define what must be verified before discussing private account information or taking actions.

# Conversation Flow
## 1) Opening
- Explain exactly how to start the call.

## 2) Identify Need / Confirm Context
- Explain what the agent should ask or confirm.

## 3) Resolve / Offer / Action
- Explain what the agent should do based on the caller’s response.

## 4) Use System Actions
- Explain exactly which actions are allowed and when.

## 5) Escalation / Transfer
- Explain when to transfer or escalate.

## 6) Close
- Explain how to summarize, say goodbye, and end the call.

# System Action Rules
- List each enabled system action and the exact situations where it may be used.

# Data Handling Rules
- Explain how to use available customer/item/pre-agent data.

# Failure Handling
- Explain what to do when lookup, payment, refund, or Function actions fail.

# End Call Rules
- Explain when and how to end the call.
```

Do not use this structure as a generic final answer. Fill it in with the user’s actual business details.



---

## Required Fields

| Field | Type | Required | Description |
|---|---:|---:|---|
| `name` | string | Yes | Internal AI Voice Agent name. |
| `call_method` | enum | Yes | `inbound` or `outbound`. |
| `settings` | object | Yes | Voice, instructions, system actions, limits, active window, and trigger settings. |
| `third_party_integration_ai` | string | Yes | 20-character user third-party integration ID for the realtime `ai` integration. Currently supported: OpenAI with `gpt-realtime-*`. Must already exist before creating the agent. |
| `third_party_integration_voice` | string | Yes | 20-character user third-party integration ID for the `ai_voice` integration. Currently supported: Twilio with a selected phone number. Must already exist before creating the agent. |

Optional but recommended:

| Field | Type | Purpose |
|---|---:|---|
| `description` | string | Explain purpose, call method, trigger, and allowed actions. |
| `enabled` | boolean | Use `false` while testing. |
| `pre_agent_function` | string | 20-character Function ID that generates dynamic instruction content. |

---

## Inbound Agent Request Example

> Before using example IDs, MCP must check `GetUserThirdPartyIntegrations` and ensure `third_party_integration_ai` is a realtime `ai` integration and `third_party_integration_voice` is an `ai_voice` integration.


The following example is intentionally shortened for readability. Do not create production agents with minimal instructions. In a real MCP workflow, draft detailed instructions specific to the user’s use case and show them to the user for review before creation.

```json
{
  "name": "Inbound Support Agent",
  "description": "Answers inbound customer support calls and helps with order, shipment, refund, and subscription questions.",
  "enabled": false,
  "call_method": "inbound",
  "third_party_integration_ai": "XXXXXXXXXXXXXXXXXXXX",
  "third_party_integration_voice": "YYYYYYYYYYYYYYYYYYYY",
  "settings": {
    "voice": "marin",
    "instructions": {
      "markdown": "# Role & Objective\n- You are an inbound customer service agent.\n\n# Conversation Flow\n## 1) Greeting\n- Greet the caller and ask how you can help.\n\n## 2) Resolve\n- Use enabled system actions only when needed.\n\n## 3) Close\n- If the caller no longer needs help, say goodbye and end the call."
    },
    "system_actions": [
      "SearchCustomers",
      "GetCustomer",
      "GetSale",
      "GetShipment",
      "CreateNote"
    ],
    "limits": {
      "max_calls_per_day": 0,
      "max_duration": 15
    }
  }
}
```

---

## Outbound On-Demand Agent Request Example

> Before using example IDs, MCP must check `GetUserThirdPartyIntegrations` and ensure `third_party_integration_ai` is a realtime `ai` integration and `third_party_integration_voice` is an `ai_voice` integration.


The following example is intentionally shortened for readability. Do not create production agents with minimal instructions. In a real MCP workflow, draft detailed outbound instructions specific to the user’s trigger, item type, offer, verification rules, and allowed system actions.

```json
{
  "name": "Outbound Customer Follow-Up",
  "description": "On-demand outbound agent that calls a customer related to a supplied item.",
  "enabled": false,
  "call_method": "outbound",
  "third_party_integration_ai": "XXXXXXXXXXXXXXXXXXXX",
  "third_party_integration_voice": "YYYYYYYYYYYYYYYYYYYY",
  "settings": {
    "voice": "marin",
    "instructions": {
      "markdown": "# Role & Objective\n- You are an outbound customer follow-up agent.\n\n# Greeting\n{{#if customer.verified}}\n- Address the customer as {{customer.first_name}}.\n{{else}}\n- Use a brief friendly greeting.\n{{/if}}\n\n# Close\n- If the caller no longer needs help, say goodbye and end the call."
    },
    "system_actions": [
      "GetCustomer",
      "GetSale",
      "CreateNote"
    ],
    "limits": {
      "max_outbound_calls_per_customer": 1,
      "max_calls_per_day": 0,
      "max_duration": 15
    },
    "trigger_settings": {
      "trigger": "on_demand"
    }
  }
}
```

---

# Field Details

## `name`

Recommended pattern:

```text
<Call Method> - <Purpose> - <Audience/Event>
```

Examples:

```text
Inbound - Customer Support
Outbound - Declined Sale Recovery
Outbound - Prospect Sales - No Sale Group
```

## `description`

Highly recommended. Include whether the agent is inbound or outbound, what triggers it, what it should help with, which system actions it may use, and whether it uses a filter Function or pre-agent Function.

## `enabled`

Use `false` while configuring and testing.

## `call_method`

Allowed values:

```text
inbound
outbound
```

## `third_party_integration_ai`

Must be a 20-character user third-party integration ID for the realtime `ai` integration.

Current supported configuration:

```text
Integration type: ai
Provider: OpenAI
Model: gpt-realtime-*
```

This integration powers the realtime AI conversation.

Before using this field, the MCP should:

1. Call `GetUserThirdPartyIntegrations`.
2. Find an existing compatible `ai` integration.
3. Confirm it is configured for realtime AI Voice Agent use.
4. Confirm it uses a supported realtime model.
5. If missing, create the integration before calling `CreateAIVoiceAgent`.

Do not use a non-realtime AI integration for this field.

---

## `third_party_integration_voice`

Must be a 20-character user third-party integration ID for the `ai_voice` integration.

Current supported configuration:

```text
Integration type: ai_voice
Provider: Twilio
Requirement: selected/usable Twilio phone number
```

This integration handles inbound and outbound phone calls.

Before using this field, the MCP should:

1. Call `GetUserThirdPartyIntegrations`.
2. Find an existing compatible `ai_voice` integration.
3. Confirm it is configured for AI Voice Agent calling.
4. Confirm it has a selected/usable phone number.
5. If missing, create the integration before calling `CreateAIVoiceAgent`.

Do not use the OpenAI integration ID for this field.

---


---

# Agent Instructions Are Critical

The MCP should never generate or submit minimal placeholder instructions for `settings.instructions.markdown`.

Before creating the AI Voice Agent, the MCP should ask the user for the agent’s exact purpose, audience, trigger, call flow, allowed actions, prohibited actions, verification rules, tone, compliance requirements, transfer rules, and success criteria.

The MCP should then draft detailed markdown instructions and show those instructions to the user for review before calling `CreateAIVoiceAgent`.

Do not create the AI Voice Agent with generic instructions like “greet the caller, help them, and end the call.” Voice-agent instructions control live customer conversations and must be specific to the business use case.


# `settings`

Required settings:

| Field | Required | Description |
|---|---:|---|
| `voice` | Yes | Voice enum, currently `marin` or `cedar`. |
| `instructions.markdown` | Yes | Markdown instructions compiled for each call. |
| `system_actions` | Yes | Array of enabled API operation IDs the AI may call. |

Optional settings:

| Field | Description |
|---|---|
| `limits` | Daily, duration, and outbound-per-customer limits. |
| `active_window` | Hours when the agent is active. |
| `trigger_settings` | Required conceptually for outbound agents. |

---

## `settings.system_actions`

System actions are opt-in API operations the AI can use during calls. Only enable actions needed for the agent's purpose.



### System Actions Are Permissions, Not Suggestions

System actions determine what the AI is allowed to do during a live call.

The AI Voice Agent can always speak based on its compiled instructions and available Handlebars input data, but it can only retrieve additional RevCent data or perform RevCent actions when the corresponding system action is included.

For example:

- Include `GetCustomer` if the agent should be able to retrieve or refresh customer details during the call.
- Include `GetSale` if the agent should be able to retrieve sale details during the call.
- Include `GetShipment` if the agent should be able to retrieve shipment/tracking details.
- Include `GetSubscription` if the agent should be able to retrieve subscription details.
- Include `TriggerFunction` only if the agent should be allowed to trigger a custom Function during the live conversation.

If a system action is not included, the AI should not be expected to use that action.

---

### When to Include Data Retrieval Actions

Data retrieval actions are usually safer than write/payment/refund actions, but they should still be included intentionally.

| Action | Include When | Do Not Include When |
|---|---|---|
| `SearchCustomers` | Inbound calls may not match a customer by phone, and the agent should search by email, phone, or name. | The agent should only help automatically matched callers or supplied outbound item context. |
| `GetCustomer` | The agent needs current customer details, customer status, customer metadata, or customer context. | The call does not require customer-specific account information. |
| `GetSale` | The agent needs sale/order/payment attempt details. | The call is not about a sale or order. |
| `GetShipment` | The agent needs tracking, shipment status, or fulfillment details. | The agent should not discuss shipping. |
| `GetSubscription` | The agent handles subscription status, cancellation, suspension, activation, or renewal questions. | The agent should not discuss subscriptions. |
| `GetSubscriptionRenewal` | The call is about a failed, successful, or upcoming renewal. | Renewals are irrelevant to the workflow. |
| `GetTransaction` | The agent needs credit card transaction details or refund context. | The call does not involve transactions or payment history. |
| `GetPendingRefund` | The agent needs pending refund details. | Refund status is not part of the workflow. |
| `GetTrial` | The call is about a trial expiration or trial cancellation. | Trials are irrelevant. |

Important: An AI Voice Agent can retrieve customer, sale, shipment, subscription, renewal, transaction, and other data during the call only when the relevant system action is enabled and the instructions tell it when to use that action.

---

### When to Include Write or Mutating Actions

Mutating actions change data or create side effects. Include them only when the business workflow requires them and the instructions define strict rules.

| Action | Include When | Required Instruction Detail |
|---|---|---|
| `CreateNote` | The agent should log the call outcome or customer request. | When to create the note and what it should contain. |
| `InsertMetadata` | The agent should tag the item/customer with call outcome metadata. | Exact metadata names and allowed values. |
| `SendSMTPMessage` | The agent should send an Email Template after or during the call. | Which template to use, when to send it, and what custom arguments are allowed. |
| `EditShipment` | The agent is allowed to update shipment data. | Exactly which fields may be edited and under what conditions. |
| `EditSubscription` | The agent is allowed to edit subscription details. | Exactly what changes are allowed. |
| `ActivateSubscription` / `SuspendSubscription` / `CancelSubscription` / `RenewSubscription` | Subscription support workflows require these actions. | Verification, eligibility, customer consent, and confirmation language. |
| `AddFraudAlert` | The agent should flag suspicious activity. | What behavior qualifies as suspicious. |

Do not include mutating actions just in case. If the action is enabled, the instructions must explain exactly when it can be used.

---

### When to Include Payment, Card, Sale, or Refund Actions

These actions are high-impact and should be included only with detailed, restrictive instructions.

| Action | Include When | Do Not Include When |
|---|---|---|
| `AddCardToCustomer` | The agent is explicitly allowed to collect and add a customer card. | The agent should not handle payment information. |
| `ProcessPendingSale` | The agent is helping complete an existing pending sale. | The agent should not attempt payment processing. |
| `CreateSale` | The agent is allowed to create a new sale during the call. | The agent is support-only or should not sell/process orders. |
| `EstimateSale` | The agent needs to quote totals before creating or processing a sale. | Pricing or checkout is not part of the call. |
| `VoidSale` | The agent may void a sale under strict conditions. | Voiding should be handled by humans. |
| `RefundTransaction` | The agent may refund credit card transactions. | Refunds require human approval. |
| `RefundProductSale` | The agent may refund product-level sale items. | Product refunds require human review. |
| `RefundShipment` | The agent may refund shipping. | Shipping refunds require human review. |
| `RefundSubscriptionRenewal` | The agent may refund subscription renewals. | Subscription refunds require human review. |
| `CancelTrial` | The agent may cancel trials. | Trial cancellations require human review. |

If any payment, card, sale, or refund action is included, the instructions should specify:

- What the agent must verify first.
- Whether customer consent is required.
- Maximum number of attempts.
- Maximum refund amount or exact refund rules.
- When to refuse.
- When to transfer to a human.
- What note/metadata to create after the action.
- What to say if the action fails.
- Whether the agent may retry.

---

### When to Include `TriggerFunction`

Include `TriggerFunction` only when the AI needs to run custom logic during the live call.

Use cases:

- Look up external CRM data.
- Generate a customer-specific offer.
- Validate an external account number.
- Call an external eligibility API.
- Calculate a custom discount.
- Log a custom event in a third-party system.
- Retrieve business-specific data not available from standard RevCent actions.

Do not include `TriggerFunction` when:

- The needed data can be inserted before the call with a pre-agent Function.
- The Function is only needed to decide whether the call should happen; use a filter Function instead.
- The AI does not need custom logic during the live conversation.
- The Function’s behavior is not clearly explained in instructions.

If `TriggerFunction` is included, the instructions should identify:

- Which Function or type of Function the AI should look for.
- When the AI should trigger it.
- What arguments it should provide.
- What to do with the Function response.
- What to say if the Function fails.

---

### System Action Selection Principle

Use the smallest safe set of system actions.

A good rule:

```text
If the instructions do not explicitly explain when the AI should use a system action, do not include that system action.
```


Available schema values include:

```text
GetCustomer
AddCardToCustomer
SearchCustomers
GetEmailTemplates
GetEmailTemplate
GetFunctions
GetFunction
TriggerFunction
InsertMetadata
CreateNote
GetPayPalTransaction
GetPendingRefund
GetProductSale
RefundProductSale
CreateSale
GetSale
VoidSale
AddFraudAlert
ProcessPendingSale
EstimateSale
GetShipment
EditShipment
RefundShipment
SendSMTPMessage
GetSMTPMessage
GetSubscriptionRenewal
RefundSubscriptionRenewal
GetSubscription
EditSubscription
ActivateSubscription
SuspendSubscription
CancelSubscription
RenewSubscription
GetTransaction
RefundTransaction
GetTrial
CancelTrial
```

---

## Outbound Trigger Settings

Only applies when `call_method` is `outbound`.

On demand:

```json
"trigger_settings": {
  "trigger": "on_demand"
}
```

Account event:

```json
"trigger_settings": {
  "trigger": "account_event",
  "account_event": {
    "notation": "sale.created.failed.declined",
    "delay_enabled": true,
    "time_value": 2,
    "time_unit": "minutes"
  },
  "limits": {
    "max_calls_per_item": 1
  }
}
```

---



---
---

# Outbound Delay Strategy for Checkout and Customer Experience

For outbound AI Voice Agents, the delay setting is an important customer-experience and conversion setting.

A delay controls how long RevCent waits after the triggering account event before attempting the outbound call.

This is especially important for checkout-related events, such as:

```text
sale.created.success.pending
sale.created.failed
sale.created.failed.declined
trial.updated.expired.failed
subscription_renewal.updated.failed
```

In these scenarios, the customer may still be actively attempting checkout, correcting payment information, reviewing the order, checking their bank app, trying a different card, or deciding whether to complete the purchase.

Calling too quickly can interrupt that process.

---

## Why Delay Matters

An outbound AI Voice Agent call can help recover revenue, but it can also disrupt the customer if it happens at the wrong time.

If the customer is still in the checkout flow, an immediate phone call may:

- Distract the customer from completing checkout.
- Make the customer feel monitored or pressured.
- Cause the customer to abandon the purchase.
- Create confusion if they are still actively fixing the issue.
- Feel intrusive if the event only happened seconds ago.
- Reduce trust if the customer thinks the business is reacting too aggressively.

For checkout-related workflows, the MCP should not treat “call as soon as possible” as the default best behavior.

The delay period should be chosen intentionally.

---

## When a Delay Is Usually Appropriate

A delay is usually appropriate when the customer may still resolve the issue without a call.

Examples:

```text
Customer has a pending sale and may still be checking out.
Customer had a soft payment decline and may try another card.
Customer may be correcting billing details.
Customer may be going through 3DS/bank verification.
Customer may be deciding whether to complete an upsell.
Customer may still be browsing or interacting with checkout.
```

In these cases, a short delay can give the customer time to complete the purchase naturally before the AI Voice Agent intervenes.

Example strategy:

```text
Pending checkout follow-up:
delay_enabled = true
time_value = 5
time_unit = minutes
```

Another strategy:

```text
Failed payment follow-up:
delay_enabled = true
time_value = 10
time_unit = minutes
```

The exact delay should depend on the business, event type, product, checkout flow, and urgency.

---

## When an Immediate or Very Short Delay May Be Appropriate

There are situations where calling quickly may be useful.

A quick call may be appropriate when the event suggests the customer needs immediate help.

Examples:

```text
The customer appears to have entered incorrect information.
The customer repeatedly fails checkout.
The customer is attempting a high-value purchase.
The customer has a known history of needing phone assistance.
The payment failure reason suggests confusion or correctable input.
The customer requested help or a callback.
The event is urgent and customer assistance is likely beneficial.
```

In these cases, a short delay or even immediate call may be reasonable, but the MCP should still think carefully about whether the call will help or interrupt.

The instructions should also make the agent’s opening gentle and helpful.

Example:

```markdown
# Opening
- Politely explain that the call is to help if the customer had trouble completing checkout.
- Do not imply the customer did anything wrong.
- Ask whether now is a good time before discussing details.
- If the customer says they are still checking out or do not want help, politely end the call.
```

---

## Choosing the Delay Time Period

The delay time period should be based on the likely customer behavior after the event.

Questions the MCP should consider:

1. Is the customer likely still in checkout?
2. Is the event a soft decline, hard decline, pending sale, failed sale, trial expiration, or renewal issue?
3. Is the customer likely to retry payment without assistance?
4. Is the product high enough value to justify fast outreach?
5. Is the call more likely to help or disturb the customer?
6. Would an email or SMS-style workflow be less intrusive before a phone call?
7. Is this an upsell, checkout, subscription renewal, trial expiration, or post-purchase event?
8. Does the customer’s previous behavior suggest phone assistance is welcome?
9. Are there legal, compliance, or quiet-hour concerns?
10. Should the first call attempt happen minutes later, hours later, or the next business day?

A delay should not be copied blindly from examples.

The MCP should recommend a delay that matches the use case.

---

## Example Delay Strategies

| Scenario | Delay Guidance | Reason |
|---|---|---|
| Pending checkout | Usually short delay, such as several minutes. | Customer may still complete checkout without help. |
| Failed card decline | Short-to-moderate delay. | Customer may retry with another card or fix billing info. |
| Repeated checkout failures | Shorter delay may be justified. | Customer may be stuck and need assistance. |
| High-value failed sale | Shorter delay may be justified. | Recovery value may justify faster outreach. |
| Subscription renewal failure | Longer delay may be acceptable. | Renewal recovery is important but usually less immediate than active checkout. |
| Trial expiration failure | Moderate delay may be appropriate. | Customer may need assistance but may not be actively checking out. |
| Shipping/delivery event | Delay depends on event. | Some events require immediate support; others are better as later follow-up. |
| Post-purchase satisfaction | Longer delay. | Customer needs time to receive or use product. |

---

## Filters Are Still Checked After the Delay

Delay does not replace filters.

For outbound account-event AI Voice Agents, filters are evaluated after the delay has expired.

This means that even if an event initially triggers the AI Voice Agent, the call should only proceed after the delay if the item still passes the configured filters.

The filter checks can include:

- Event filters
- Status filters
- Campaign filters
- Metadata filters
- Customer filters
- Call limits
- Active window checks
- Filter Function result

The filter Function must still return:

```javascript
callback(null, 'pass');
```

for the call to proceed.

If the filter Function returns:

```javascript
callback(null, 'fail');
```

the outbound call should not happen, even after the delay has expired.

---

## Why Post-Delay Filtering Matters

Post-delay filtering prevents stale or unnecessary calls.

Example:

```text
Customer has failed checkout event
  ↓
AI Voice Agent waits 10 minutes
  ↓
Customer successfully completes checkout during the delay
  ↓
Filters are checked again after delay
  ↓
Sale no longer qualifies
  ↓
AI Voice Agent should not call
```

Another example:

```text
Subscription renewal fails
  ↓
AI Voice Agent waits 30 minutes
  ↓
Customer updates payment method and renewal succeeds
  ↓
Filter Function checks current state
  ↓
Function returns fail
  ↓
No unnecessary recovery call is made
```

This is critical because the customer’s situation may change during the delay period.

---

## Filter Function Design for Delayed Calls

When a delayed outbound call uses a filter Function, the Function should check the current state of the item, not only the original event state.

Good filter Function logic:

```text
Pass only if the sale is still pending or failed.
Pass only if the subscription renewal is still failed.
Pass only if the customer has not already completed payment.
Pass only if the customer has not opted out.
Pass only if no recent successful call or recovery happened.
Fail if the issue has already been resolved.
```

Example:

```javascript
exports.handler = async function(event, context, callback) {
  const sale = event?.data?.item_details || {};

  if (sale.status === 'paid' || sale.status === 'complete') {
    return callback(null, 'fail');
  }

  if (sale.metadata?.ai_voice_recovery_completed === 'true') {
    return callback(null, 'fail');
  }

  if (!sale.customer?.phone) {
    return callback(null, 'fail');
  }

  return callback(null, 'pass');
};
```

The exact field names should be based on the example input data for the relevant item type.

---

## Customer-Friendly Agent Instructions for Delayed Checkout Calls

When calling after a checkout-related delay, the agent instructions should be respectful and non-disruptive.

Recommended instruction language:

```markdown
# Checkout Timing and Customer Respect
- This call may occur shortly after the customer attempted checkout.
- The customer may still be completing checkout or may have already resolved the issue.
- Open gently and position the call as optional assistance.
- Do not pressure the customer.
- Ask whether now is a good time.
- If the customer says they are still checking out, already completed the order, or does not want help, politely acknowledge and end the call.
- Do not imply that the customer made a mistake unless the data clearly shows incorrect information and the wording is framed as helpful assistance.
```

Example opening:

```markdown
# Opening
- Say: "Hi, this is the support team calling because it looked like you may have had trouble completing checkout. I just wanted to see if you wanted help, but if you are still working on it or already finished, no problem."
```

---

## MCP Guidance

When creating or editing an outbound AI Voice Agent, MCP should explicitly consider delay settings.

The MCP should ask or decide:

1. Could the customer still be attempting checkout when the event fires?
2. Would calling immediately help or interrupt?
3. Is the trigger event a checkout, failed payment, pending sale, renewal, trial, shipping, or follow-up event?
4. What delay gives the customer enough time to self-resolve?
5. Is the delay short enough to still recover the opportunity?
6. Should the filter Function check whether the issue was resolved during the delay?
7. Should the agent opening acknowledge that the customer may already have resolved the issue?
8. Should the agent be instructed to end quickly if the customer is busy, still checking out, or uninterested?

Important rule:

```text
Delay strategy is part of customer experience design, not just a technical trigger setting.
```


# Canonical AI Voice Agent Data Model: Filter Function vs Pre-Agent Function vs Instruction Compile Data

AI Voice Agents can use three different kinds of dynamic logic/data around a call:

1. **Filter Function** — decides whether an outbound call should happen.
2. **Pre-Agent Function** — runs before the AI Voice Agent instructions are compiled and returns custom data for Handlebars.
3. **AI Voice Agent instruction compile data** — the built-in data RevCent provides when compiling `settings.instructions.markdown` for the specific call.

These are related, but they are not the same thing.

| Concept | When It Runs | Main Purpose | Input Data Source | Output / Usage |
|---|---|---|---|---|
| Filter Function | Before an outbound call is allowed to run. | Decide whether the AI Voice Agent should call the item/customer. | Item-specific filter body based on `item_type`. | Must return `pass` or `fail`. |
| Pre-Agent Function | Before the AI Voice Agent instructions are compiled. | Generate custom dynamic content for Handlebars in the agent instructions. | Pre-agent body based on outbound/inbound context. | Response becomes available to instructions as `pre_agent_function`. |
| Instruction Compile Data | During Handlebars compilation before the call starts. | Provide built-in call, item, customer, and context data to the instructions. | AI Voice Agent input-data body based on outbound/inbound context. | Used directly in `settings.instructions.markdown`. |
| Function Triggered During Instructions | During the live call, if `TriggerFunction` system action is enabled. | Run custom logic during the conversation. | Arguments generated by the AI during the live call. | Function result is used during the conversation. |

The MCP must not mix these up.

---

## Simple Difference

```text
Filter Function = Should this outbound call happen?
Pre-Agent Function = What extra custom data should be injected into the instructions before the call?
Instruction Compile Data = What built-in RevCent data is available to Handlebars when the instructions compile?
TriggerFunction = What custom logic can the AI run during the live call?
```

---

---

# Detailed Filter, Pre-Agent, Customer, and Snippet Behavior

This section is especially important for MCP/API clients that need to create or edit AI Voice Agents correctly.

The AI Voice Agent system has four separate data/function concepts that must not be confused:

```text
Filter Function
Pre-Agent Function
Instruction input_data / Handlebars compile data
AI Voice Snippets
```

---

## Detailed Filter Function `pass` / `fail` Behavior

A filter Function is a gatekeeper for outbound AI Voice Agent calls.

It answers one question:

```text
Should this outbound AI Voice Agent call run for this item?
```

The filter Function receives item-specific data for the event or on-demand item, based on the triggering `item_type`.

Example data URL format:

```text
https://revcent.com/documentation/files/function/event/filter/[item_type].json
```

Examples:

```text
https://revcent.com/documentation/files/function/event/filter/customer.json
https://revcent.com/documentation/files/function/event/filter/sale.json
https://revcent.com/documentation/files/function/event/filter/shipping.json
https://revcent.com/documentation/files/function/event/filter/subscription.json
https://revcent.com/documentation/files/function/event/filter/subscription_renewal.json
https://revcent.com/documentation/files/function/event/filter/chargeback.json
https://revcent.com/documentation/files/function/event/filter/fraud_detection.json
```

The Function must return one of two exact single-term results:

```javascript
callback(null, 'pass');
```

or:

```javascript
callback(null, 'fail');
```

Meaning:

| Return | Meaning | Result |
|---|---|---|
| `pass` | The item passes the filter. | The AI Voice Agent call is allowed to run. |
| `fail` | The item fails the filter. | The AI Voice Agent call is blocked/skipped. |

Important:

```text
Default behavior is pass.
```

That means if the Function is not present, or if the filtering configuration does not block the item, the outbound call may proceed according to the rest of the agent trigger settings.

However, if a filter Function is used, the MCP should ensure the Function explicitly returns `pass` or `fail`.

---

## Filter Function Return Rules

A filter Function should not return:

```javascript
callback(null, true);
callback(null, false);
callback(null, { result: 'pass' });
callback(null, { status: 'fail' });
callback(null, 'approved');
callback(null, 'blocked');
```

Correct:

```javascript
callback(null, 'pass');
```

Correct:

```javascript
callback(null, 'fail');
```

The return must be a single term.

The MCP should write filter Functions so all code paths end in either `pass` or `fail`.

Example:

```javascript
exports.handler = async function(event, context, callback) {
  const item = event?.data?.item_details || {};

  if (item.metadata?.do_not_call === 'true') {
    return callback(null, 'fail');
  }

  if (item.customer?.phone_opt_out === true) {
    return callback(null, 'fail');
  }

  return callback(null, 'pass');
};
```

---

## When to Return `pass`

Return `pass` when the item is eligible for the outbound call.

Examples:

```text
Sale is still pending or recoverable.
Customer has not opted out.
Customer has a valid phone number.
Shipment event is important enough for a call.
Subscription renewal is still failed/overdue.
Customer is in the right campaign or shop.
Chargeback risk requires proactive outreach.
```

Example:

```javascript
if (item.status === 'pending' && item.customer?.phone) {
  return callback(null, 'pass');
}
```

---

## When to Return `fail`

Return `fail` when the call should not happen.

Examples:

```text
Customer opted out.
Customer has no usable phone number.
Customer is in a suppression group.
Sale is already paid or no longer recoverable.
Shipment is not customer-impacting.
Subscription was already renewed.
Customer has already been called enough times.
Customer is not in the correct campaign/shop/brand.
The item does not meet value or priority thresholds.
```

Example:

```javascript
if (!item.customer?.phone) {
  return callback(null, 'fail');
}
```

---

## Filter Functions Are for Eligibility, Not Agent Personalization

A filter Function is not the right place to generate dynamic call instructions.

Use a filter Function for:

```text
Should the call run?
```

Use a pre-agent Function for:

```text
What extra custom data should be available when compiling the instructions?
```

Use `TriggerFunction` for:

```text
What custom logic should the AI run during the live conversation?
```

---

# Detailed Pre-Agent Function Behavior

A pre-agent Function runs immediately before the AI Voice Agent instructions are compiled.

It receives call/item context and returns JSON data that becomes available to the instruction compiler.

A pre-agent Function is useful when the agent needs custom dynamic data that is not already available in the built-in instruction input data.

Examples:

```text
Brand name based on campaign
Custom offer based on customer value
Product list to mention during the call
Refund rules from an external system
CRM account status
Risk classification
Support priority
Approved talking points
Do-not-say instructions
```

---

## Pre-Agent Function Input Data URLs

For outbound calls triggered by account event or api_direct/on-demand, pre-agent Function input data uses this URL format:

```text
https://revcent.com/documentation/files/function/event/pre_agent/outbound/[item_type].json
```

Examples:

```text
https://revcent.com/documentation/files/function/event/pre_agent/outbound/customer.json
https://revcent.com/documentation/files/function/event/pre_agent/outbound/sale.json
https://revcent.com/documentation/files/function/event/pre_agent/outbound/shipping.json
https://revcent.com/documentation/files/function/event/pre_agent/outbound/subscription.json
https://revcent.com/documentation/files/function/event/pre_agent/outbound/subscription_renewal.json
https://revcent.com/documentation/files/function/event/pre_agent/outbound/chargeback.json
https://revcent.com/documentation/files/function/event/pre_agent/outbound/fraud_detection.json
```

For inbound calls, the pre-agent input data depends on whether the inbound caller phone number matches an existing customer.

Inbound with customer match:

```text
https://revcent.com/documentation/files/function/event/pre_agent/inbound/customer_match.json
```

Inbound with no customer match:

```text
https://revcent.com/documentation/files/function/event/pre_agent/inbound/no_customer_match.json
```

---

## What a Pre-Agent Function Should Return

A pre-agent Function should return a plain JSON object.

Example:

```javascript
callback(null, {
  company_name: 'Acme Inc.',
  allow_full_refunds: false,
  offer_allowed: true,
  offer_text: 'Free shipping is available if the customer completes the order today.',
  product_list: [
    {
      name: 'Product A',
      price: 29.99
    },
    {
      name: 'Product B',
      price: 49.99
    }
  ],
  support_priority: 'high'
});
```

The pre-agent response should be:

- JSON serializable
- Structured
- Predictable
- Safe to inject into instructions
- Specific to the call
- Free of secrets or private internal credentials
- Written so the instruction document can reference known paths

Avoid returning unclear freeform text that gives the AI unsafe latitude.

Poor return:

```javascript
callback(null, {
  text: 'Say whatever you need to make them buy.'
});
```

Better return:

```javascript
callback(null, {
  offer_allowed: true,
  approved_offer_name: 'Free Shipping Recovery Offer',
  approved_offer_terms: 'Free standard shipping if the customer completes payment today.',
  max_discount_percent: 0,
  must_not_offer: [
    'Cash refund',
    'Unapproved discount',
    'Guaranteed delivery date'
  ]
});
```

---

## How Pre-Agent Function Data Appears in Instruction Compile Data

When a pre-agent Function returns a valid JSON object, RevCent makes it available to the AI Voice Agent instruction compiler under:

```text
pre_agent_function
```

The structure is:

```json
{
  "pre_agent_function": {
    "has_response": true,
    "response": {
      "company_name": "Acme Inc.",
      "allow_full_refunds": false
    }
  }
}
```

Use this in Handlebars as:

```handlebars
{{pre_agent_function.response.company_name}}
```

or:

```handlebars
{{#if pre_agent_function.response.allow_full_refunds}}
- The agent may offer a full refund if the customer qualifies under the refund rules.
{{else}}
- The agent must not offer a full refund.
{{/if}}
```

Important:

```text
Access returned fields through pre_agent_function.response.*
```

Do not assume the returned values are at the top level.

Wrong:

```handlebars
{{company_name}}
```

Correct:

```handlebars
{{pre_agent_function.response.company_name}}
```

---

## Guarding Pre-Agent Function References

The MCP should use guards around pre-agent data because the Function may not run, may fail, or may return no usable data.

Recommended:

```handlebars
{{#if pre_agent_function.has_response}}
Use this custom context:
{{{toString pre_agent_function.response}}}
{{/if}}
```

For individual fields:

```handlebars
{{#if pre_agent_function.response.company_name}}
- Identify as {{pre_agent_function.response.company_name}} customer support.
{{else}}
- Identify as customer support.
{{/if}}
```

For JSON arrays or objects, use triple braces with `toString`:

```handlebars
# Available Products
{{{toString pre_agent_function.response.product_list}}}
```

---

## Good Pre-Agent Function Use Cases

Use a pre-agent Function when the instructions need call-specific content before the call begins.

Examples:

```text
Determine brand name from campaign.
Generate an approved offer from external CRM data.
Create a product list for a sales agent.
Return refund/cancellation rules for this customer.
Summarize customer risk or support priority.
Pull external subscription entitlement data.
Generate a personalized call objective.
Return internal escalation rules based on customer status.
```

A pre-agent Function is often better than `TriggerFunction` when the data is needed before the first words of the call.

---

## Pre-Agent Function vs AI Voice Snippets

Pre-agent Functions and AI Voice Snippets are different.

| Concept | Purpose |
|---|---|
| Pre-Agent Function | Generates dynamic JSON data before the call based on the call/item context. |
| AI Voice Snippet | Reusable instruction content that can be compiled and inserted into the main instructions. |

A pre-agent Function is best for data.

A snippet is best for reusable instruction text.

They can work together.

Example:

```handlebars
{{snippets.card_guidelines}}

{{#if pre_agent_function.response.company_name}}
- Brand voice: represent {{pre_agent_function.response.company_name}}.
{{/if}}
```

---

# Outbound Calls Always Include a Top-Level `customer` Object

For outbound AI Voice Agent calls, the instruction compile input data will always include a top-level `customer` object outside of the `item` object.

This is important for Handlebars safety and consistency.

The MCP should prefer:

```handlebars
{{customer.first_name}}
```

instead of trying to branch based on the outbound item type.

Do not require different customer paths like:

```handlebars
{{item.item_details.first_name}}
```

for `customer` item type, or:

```handlebars
{{item.item_details.customer.first_name}}
```

for non-customer item types.

For outbound calls, use the top-level customer object:

```handlebars
{{#if customer.first_name}}
- Address the customer as {{customer.first_name}}.
{{else}}
- Use a friendly generic greeting.
{{/if}}
```

This allows one instruction pattern to work across outbound calls for different item types.

---

## Why the Top-Level Customer Object Matters

Outbound calls can be triggered by many item types:

```text
customer
sale
shipping
subscription
subscription_renewal
chargeback
fraud_detection
```

The customer may live in different places inside each item’s raw details.

Examples:

```text
customer item_type:
item.item_details.first_name
```

```text
sale item_type:
item.item_details.customer.first_name
```

```text
shipping item_type:
item.item_details.customer.first_name
```

But RevCent provides a normalized top-level `customer` object for outbound instruction compilation.

Therefore, the MCP should write outbound instructions against:

```text
customer.first_name
customer.last_name
customer.email
customer.phone
customer.id
customer.verified
```

This keeps instructions cleaner and safer.

---

## Outbound Instruction Compile Data URLs

Outbound call instruction compile data examples use:

```text
https://revcent.com/documentation/files/ai_voice_agent/outbound/[item_type].json
```

Examples:

```text
https://revcent.com/documentation/files/ai_voice_agent/outbound/customer.json
https://revcent.com/documentation/files/ai_voice_agent/outbound/sale.json
https://revcent.com/documentation/files/ai_voice_agent/outbound/shipping.json
https://revcent.com/documentation/files/ai_voice_agent/outbound/subscription.json
https://revcent.com/documentation/files/ai_voice_agent/outbound/subscription_renewal.json
https://revcent.com/documentation/files/ai_voice_agent/outbound/chargeback.json
https://revcent.com/documentation/files/ai_voice_agent/outbound/fraud_detection.json
```

These are the correct examples for AI Voice Agent outbound instruction compile data.

Do not use Function account-event body URLs as outbound instruction compile-data examples.

---

# AI Voice Snippets

AI Voice Snippets are reusable pieces of instruction content that can be compiled and inserted into the main AI Voice Agent instructions.

The compiled snippets are available to the main instruction document through the `snippets` object.

Example input data structure:

```json
{
  "snippets": {
    "card_guidelines": "Do not interrupt if the caller is providing card information."
  }
}
```

Reference a snippet in the main instructions:

```handlebars
{{snippets.card_guidelines}}
```

Snippets are useful for reusable instruction blocks such as:

- Card handling rules
- Refund policy
- Verification rules
- Transfer rules
- Tone and compliance guidelines
- Subscription cancellation rules
- Chargeback escalation rules
- Shipping support rules
- Disclosure language
- End-call behavior

---

## Snippets Are Instruction Text, Not Data Fetching

AI Voice Snippets should be treated as reusable instruction content.

They should not be used as a replacement for:

- Pre-agent Functions
- Filter Functions
- System actions
- TriggerFunction
- Data retrieval operations

Use snippets when the same instruction section should be reused across multiple AI Voice Agents.

Use pre-agent Functions when dynamic data must be generated for a specific call.

---

## Snippet and Pre-Agent Function Example

Example main instruction pattern:

```handlebars
# Card Handling Rules
{{snippets.card_guidelines}}

# Brand Context
{{#if pre_agent_function.response.company_name}}
- Identify as {{pre_agent_function.response.company_name}}.
{{else}}
- Identify as customer support.
{{/if}}

# Product List
{{#if pre_agent_function.response.product_list}}
{{{toString pre_agent_function.response.product_list}}}
{{/if}}
```

This combines:

```text
Reusable rules from snippets
+
Dynamic call-specific data from pre_agent_function.response
```

---

# MCP Guidance for Data-Safe Instruction Writing

When writing AI Voice Agent instructions, MCP should:

1. Use top-level `customer.*` fields for outbound customer personalization.
2. Use `item.*` fields for the triggering item context.
3. Use `pre_agent_function.response.*` for pre-agent Function return values.
4. Use `snippets.*` for reusable compiled snippet content.
5. Use `{{#if ...}}` guards around optional data.
6. Use `{{{toString ...}}}` for objects and arrays.
7. Avoid referencing raw nested customer paths inside `item.item_details` when top-level `customer` is available.
8. Avoid using Function account-event body URLs as AI Voice Agent instruction compile-data examples.
9. Keep filter Functions limited to `pass` / `fail` eligibility decisions.
10. Keep pre-agent Functions focused on structured JSON data for instruction compilation.

# Filter Functions

A filter Function is used to decide whether an outbound AI Voice Agent call should proceed.

A filter Function receives data specific to the `item_type` that triggered the AI Voice Agent.

For AI Voice Agent filter Functions, the example input data for each item type follows this URL format:

```text
https://revcent.com/documentation/files/function/event/filter/[item_type].json
```

Examples:

```text
https://revcent.com/documentation/files/function/event/filter/customer.json
https://revcent.com/documentation/files/function/event/filter/sale.json
https://revcent.com/documentation/files/function/event/filter/shipping.json
https://revcent.com/documentation/files/function/event/filter/subscription.json
https://revcent.com/documentation/files/function/event/filter/subscription_renewal.json
https://revcent.com/documentation/files/function/event/filter/chargeback.json
https://revcent.com/documentation/files/function/event/filter/fraud_detection.json
```

The filter Function body is based on the item that would trigger or receive the outbound call.

Examples:

```text
Outbound call triggered by sale item
  ↓
Filter Function receives sale-specific body
  ↓
Function returns pass or fail
```

```text
Outbound call triggered by shipping item
  ↓
Filter Function receives shipping-specific body
  ↓
Function returns pass or fail
```

---

## Filter Function Response

A filter Function should return either:

```javascript
callback(null, 'pass')
```

or:

```javascript
callback(null, 'fail')
```

Meaning:

| Response | Meaning |
|---|---|
| `pass` | The AI Voice Agent may proceed with the outbound call. |
| `fail` | The AI Voice Agent should not proceed with the outbound call. |

A filter Function is mostly used to save cost, reduce unnecessary calls, and prevent calls that should not happen.

Use filter Functions for questions like:

```text
Should this sale receive an outbound call?
Is this customer eligible to be called?
Is this shipping event worth calling about?
Is this renewal recoverable?
Is this customer suppressed or opted out?
Is this item high value enough to call?
```

---

## Filter Function Is Not for Instruction Content

A filter Function should not be treated as a way to generate Handlebars content for the AI Voice Agent instructions.

Use a filter Function to decide:

```text
call or do not call
```

Use a pre-agent Function to generate:

```text
custom instruction content
```

---

# Pre-Agent Functions

A pre-agent Function runs before the AI Voice Agent instructions are compiled.

Its purpose is to generate custom content that can be used in the AI Voice Agent instructions through Handlebars.

A pre-agent Function is especially useful when the agent needs business-specific context that RevCent’s built-in compile data does not already provide.

Examples:

```json
{
  "offer_allowed": true,
  "offer_text": "Offer free shipping if the customer completes payment today.",
  "support_priority": "high",
  "recommended_script": "Mention the customer is eligible for priority support."
}
```

The pre-agent Function response can then be used in instructions through the `pre_agent_function` object.

Example Handlebars:

```handlebars
{{#if pre_agent_function.offer_allowed}}
Offer the customer this approved offer: {{pre_agent_function.response.offer_text}}
{{/if}}
```

---

## Outbound Pre-Agent Function Input Data

A pre-agent Function fired on an outbound call can happen when the outbound call is triggered by:

```text
account_event
api_direct / on-demand
```

For outbound calls, the pre-agent Function input data uses this URL format:

```text
https://revcent.com/documentation/files/function/event/pre_agent/outbound/[item_type].json
```

Examples:

```text
https://revcent.com/documentation/files/function/event/pre_agent/outbound/customer.json
https://revcent.com/documentation/files/function/event/pre_agent/outbound/sale.json
https://revcent.com/documentation/files/function/event/pre_agent/outbound/shipping.json
https://revcent.com/documentation/files/function/event/pre_agent/outbound/subscription.json
https://revcent.com/documentation/files/function/event/pre_agent/outbound/subscription_renewal.json
https://revcent.com/documentation/files/function/event/pre_agent/outbound/chargeback.json
https://revcent.com/documentation/files/function/event/pre_agent/outbound/fraud_detection.json
```

The `[item_type]` is the item type that triggered or was supplied to the outbound call.

Examples:

```text
Outbound on-demand call for sale
  ↓
Pre-agent Function input:
https://revcent.com/documentation/files/function/event/pre_agent/outbound/sale.json
```

```text
Outbound account-event call for shipping
  ↓
Pre-agent Function input:
https://revcent.com/documentation/files/function/event/pre_agent/outbound/shipping.json
```

---

## Inbound Pre-Agent Function Input Data

A pre-agent Function fired on an inbound call depends on whether the inbound caller number matches an existing customer.

If the inbound caller number matches an existing customer, the pre-agent Function input data uses this URL:

```text
https://revcent.com/documentation/files/function/event/pre_agent/inbound/customer_match.json
```

If the inbound caller number does not match an existing customer, the pre-agent Function input data uses this URL:

```text
https://revcent.com/documentation/files/function/event/pre_agent/inbound/no_customer_match.json
```

This distinction matters because an inbound call with a customer match has customer context available before the call, while an inbound call without a customer match does not.

---

## Pre-Agent Function Output

The pre-agent Function output should be designed as structured JSON that the instructions can safely use.

Good pre-agent output:

```json
{
  "eligible_for_offer": true,
  "offer_name": "Free Shipping Recovery Offer",
  "talking_points": [
    "The customer recently had a declined payment.",
    "The customer can complete the purchase today."
  ],
  "do_not_discuss": [
    "Internal fraud scores",
    "Internal risk rules"
  ]
}
```

Poor pre-agent output:

```json
{
  "text": "Say whatever you think will make them buy."
}
```

The pre-agent Function should produce clear, constrained, instruction-safe data.

---

# AI Voice Agent Instruction Compile Data

AI Voice Agent instructions are compiled with Handlebars before the call starts.

This compile-time data is separate from filter Function input and separate from pre-agent Function input.

The available instruction compile data depends on:

- Whether the call is inbound or outbound
- For outbound calls, the `item_type`
- For inbound calls, whether the caller number matched an existing customer
- Whether a pre-agent Function returned data
- Whether AI Voice Snippets are available

---

## Outbound Instruction Compile Data

For outbound calls triggered by either:

```text
account_event
api_direct / on-demand
```

the AI Voice Agent instruction compile data uses this URL format:

```text
https://revcent.com/documentation/files/ai_voice_agent/outbound/[item_type].json
```

Examples:

```text
https://revcent.com/documentation/files/ai_voice_agent/outbound/customer.json
https://revcent.com/documentation/files/ai_voice_agent/outbound/sale.json
https://revcent.com/documentation/files/ai_voice_agent/outbound/shipping.json
https://revcent.com/documentation/files/ai_voice_agent/outbound/subscription.json
https://revcent.com/documentation/files/ai_voice_agent/outbound/subscription_renewal.json
https://revcent.com/documentation/files/ai_voice_agent/outbound/chargeback.json
https://revcent.com/documentation/files/ai_voice_agent/outbound/fraud_detection.json
```

This is the data available to `settings.instructions.markdown` when Handlebars compiles for that outbound call.

Example:

```text
Outbound call for sale
  ↓
Instruction compile data:
https://revcent.com/documentation/files/ai_voice_agent/outbound/sale.json
```

Important:

The outbound pre-agent Function input body and outbound AI Voice Agent instruction compile data are different schemas:

```text
Pre-agent outbound function body:
https://revcent.com/documentation/files/function/event/pre_agent/outbound/[item_type].json

Instruction compile data:
https://revcent.com/documentation/files/ai_voice_agent/outbound/[item_type].json
```

Do not assume paths are identical between them.

---

## Inbound Instruction Compile Data

For inbound calls, the AI Voice Agent instruction compile data depends on whether the inbound caller number matches an existing customer.

If the inbound caller number matches an existing customer, the instruction compile data uses this URL:

```text
https://revcent.com/documentation/files/ai_voice_agent/inbound/customer_match.json
```

If the inbound caller number does not match an existing customer, the instruction compile data uses this URL:

```text
https://revcent.com/documentation/files/ai_voice_agent/inbound/no_customer_match.json
```

This distinction is important for writing safe instructions.

For customer-match inbound calls, instructions may be able to reference matched customer context, but should still follow verification rules before discussing private account details.

For no-customer-match inbound calls, instructions should not assume a customer exists. The agent may need to use `SearchCustomers` if that system action is enabled and the caller provides identifying details.

---

## Inbound Pre-Agent vs Inbound Instruction Compile Data

Inbound pre-agent Function input files:

```text
https://revcent.com/documentation/files/function/event/pre_agent/inbound/customer_match.json
https://revcent.com/documentation/files/function/event/pre_agent/inbound/no_customer_match.json
```

Inbound AI Voice Agent instruction compile data files:

```text
https://revcent.com/documentation/files/ai_voice_agent/inbound/customer_match.json
https://revcent.com/documentation/files/ai_voice_agent/inbound/no_customer_match.json
```

Do not confuse these.

The pre-agent Function receives the pre-agent event body.

The AI Voice Agent instructions receive the AI Voice Agent compile data.

---

# Data Availability Decision Table

| Call Scenario | Filter Function Input | Pre-Agent Function Input | Instruction Compile Data |
|---|---|---|---|
| Outbound account-event call for `[item_type]` | `https://revcent.com/documentation/files/function/event/filter/[item_type].json` | `https://revcent.com/documentation/files/function/event/pre_agent/outbound/[item_type].json` | `https://revcent.com/documentation/files/ai_voice_agent/outbound/[item_type].json` |
| Outbound api_direct / on-demand call for `[item_type]` | `https://revcent.com/documentation/files/function/event/filter/[item_type].json` if a filter is used | `https://revcent.com/documentation/files/function/event/pre_agent/outbound/[item_type].json` | `https://revcent.com/documentation/files/ai_voice_agent/outbound/[item_type].json` |
| Inbound call with customer match | Not applicable | `https://revcent.com/documentation/files/function/event/pre_agent/inbound/customer_match.json` | `https://revcent.com/documentation/files/ai_voice_agent/inbound/customer_match.json` |
| Inbound call with no customer match | Not applicable | `https://revcent.com/documentation/files/function/event/pre_agent/inbound/no_customer_match.json` | `https://revcent.com/documentation/files/ai_voice_agent/inbound/no_customer_match.json` |

---

# Function Triggered During Agent Instructions

A Function triggered during agent instructions is different from both a filter Function and a pre-agent Function.

This pattern requires the `TriggerFunction` system action.

It runs during the live conversation when the AI decides, based on the instructions, that it needs to trigger a custom Function.

Use `TriggerFunction` for live-call needs such as:

- Look up external CRM data during the call
- Validate an external account number
- Generate a real-time offer
- Call an external eligibility API
- Calculate a custom discount
- Log a custom event to a third-party system
- Retrieve business-specific data not available in built-in RevCent actions

Do not use `TriggerFunction` when:

- The Function is only deciding whether the call should happen; use a filter Function.
- The Function should generate instruction content before the call; use a pre-agent Function.
- The data can be provided by built-in compile data or enabled system actions.
- The instructions do not clearly explain when to trigger the Function.

---

# MCP Rules for Writing Instructions With These Data Sources

When generating or editing `settings.instructions.markdown`, MCP should follow these rules:

1. Determine the call method: `inbound` or `outbound`.
2. For outbound calls, determine the trigger and `item_type`.
3. Use the correct outbound instruction compile data reference:
   ```text
   https://revcent.com/documentation/files/ai_voice_agent/outbound/[item_type].json
   ```
4. For inbound calls, determine whether the instructions should handle both customer-match and no-customer-match cases.
5. Use the correct inbound instruction compile data references:
   ```text
   https://revcent.com/documentation/files/ai_voice_agent/inbound/customer_match.json
   https://revcent.com/documentation/files/ai_voice_agent/inbound/no_customer_match.json
   ```
6. If a pre-agent Function is configured, use the correct pre-agent input reference for the call type.
7. Use `{{#if ...}}` guards around optional customer, item, and pre-agent data.
8. Do not reference item-specific fields unless they exist for the selected `item_type`.
9. Do not assume a caller is verified just because an inbound phone number matched a customer.
10. Include system actions only when the agent needs to retrieve or mutate data during the live call.
11. Use `TriggerFunction` only for live-call custom logic, not for filtering or pre-call instruction compilation.

---

## Safe Handlebars Pattern

Use guarded references:

```handlebars
{{#if customer}}
Customer context may be available, but verify the caller before discussing private account details.
{{/if}}

{{#if item}}
This outbound call is related to {{item.item_type}} {{item.item_id}}.
{{/if}}

{{#if pre_agent_function}}
Use the following approved custom context:
{{{toString pre_agent_function.response}}}
{{/if}}
```

Avoid unguarded assumptions:

```handlebars
Hi {{customer.first_name}}, I see your order failed.
```

unless the selected compile data guarantees those fields and the instructions still handle verification correctly.

# Detailed Agent Instructions Guidance

`settings.instructions.markdown` is the primary behavior document for the AI Voice Agent. It is compiled before each call and then provided to the realtime voice model.

Good instructions are structured, explicit, and narrow. They should not merely say “help the customer.” They should define the agent's role, tone, data access, verification requirements, system action usage, conversation flow, escalation behavior, and call-ending rules.

Recommended sections:

```markdown
# Role & Objective
# Personality & Tone
# Language
# Available Context
# Verification Rules
# Conversation Flow
# System Action Rules
# Payment Rules
# Refund Rules
# Transfer Rules
# End Call Rules
# Notes and Metadata
```

---

## Instructions Should Explain Available Context

The AI Voice Agent receives precompiled Handlebars context before the call. The context depends on the call method and trigger.

The agent may receive:

- `call_method`
- `agent`
- `item`
- `customer`
- `pre_agent_function`
- `snippets`

Example general Handlebars data shape:

```json
{
  "call_method": "outbound",
  "agent": {
    "id": "Vk7ar0u9RY9ol9WBBv70",
    "name": "MyAgent"
  },
  "item": {
    "has_item_details": true,
    "item_type": "sale",
    "item_id": "JBAy1XMbGAcm1pbQ57l9",
    "item_details": {}
  },
  "customer": {
    "verified": true,
    "id": "Bv70Vk7ar0u9R9WBY9ol",
    "first_name": "George",
    "last_name": "Washington",
    "email": "george@example.com",
    "phone": "202-456-1111"
  },
  "pre_agent_function": {
    "has_response": true,
    "response": {}
  },
  "snippets": {}
}
```

Important:

- Handlebars input is compiled before the call starts.
- System actions can still retrieve more data during the call if those actions are enabled.
- For example, even if the compiled instructions only include the customer ID, the AI can call `GetCustomer` during the conversation if `GetCustomer` is included in `system_actions`.

---

## Outbound Call Input Data

Outbound calls always have an item context because outbound calls are triggered by an event item or an on-demand item.

The item type determines what `item.item_details` contains.

Supported on-demand trigger item types:

```text
sale
customer
product_sale
shipping
subscription
subscription_renewal
salvage_transaction
transaction
chargeback
fraud_detection
```

For outbound account-event calls, the item type is determined by the first word of the event notation.

Examples:

| Event notation | Item type | Event body JSON reference |
|---|---|---|
| `sale.created.failed.declined` | `sale` | `https://revcent.com/documentation/files/ai_voice_agent/outbound/sale.json` |
| `customer.created` | `customer` | `https://revcent.com/documentation/files/ai_voice_agent/outbound/customer.json` |
| `shipping.updated.shipped` | `shipping` | `https://revcent.com/documentation/files/ai_voice_agent/outbound/shipping.json` |
| `subscription_renewal.updated.failed` | `subscription_renewal` | `https://revcent.com/documentation/files/ai_voice_agent/outbound/subscription_renewal.json` |
| `transaction.created` | `transaction` | `https://revcent.com/documentation/files/ai_voice_agent/outbound/transaction.json` |
| `chargeback.created` | `chargeback` | `https://revcent.com/documentation/files/ai_voice_agent/outbound/chargeback.json` |
| `fraud_detection.created` | `fraud_detection` | `https://revcent.com/documentation/files/ai_voice_agent/outbound/fraud_detection.json` |
| `trial.updated.expired.failed` | `trial` | `https://revcent.com/documentation/files/ai_voice_agent/outbound/trial.json` |

The link pattern is:

```text
https://revcent.com/documentation/files/ai_voice_agent/outbound/[item_type].json
```

For on-demand AI Voice Agent calls, the event body is similar item context but without event notations. The item type and item ID come from `TriggerAIVoiceAgent`.


---

## Outbound Handlebars Examples

Use outbound item data directly in instructions when the value is present in the compiled input data.

Example:

```handlebars
{{#if customer.verified}}
- Address the customer as {{customer.first_name}}.
{{else}}
- Use a generic greeting.
{{/if}}
```

Embed the full item details for the AI when needed:

```handlebars
# Trigger Item Details
{{{toString item.item_details}}}
```

Use event-specific content:

```handlebars
{{#ifEquals item.item_type "sale"}}
- This call is about a sale. Use GetSale if you need current sale details during the call.
{{/ifEquals}}
```

---

## Inbound Call Input Data

Inbound calls may or may not have a customer match.

### Inbound With Customer Match

When an inbound caller phone number matches an existing customer, RevCent can provide customer context.

Conceptual input data:

```json
{
  "call_method": "inbound",
  "item": {
    "has_item_details": true,
    "item_type": "customer",
    "item_id": "XXXXXXXXXXXXXXXXXXXX",
    "item_details": {
      "id": "XXXXXXXXXXXXXXXXXXXX",
      "first_name": "George",
      "last_name": "Washington"
    }
  },
  "customer": {
    "verified": true,
    "id": "XXXXXXXXXXXXXXXXXXXX",
    "first_name": "George",
    "last_name": "Washington",
    "email": "george@example.com",
    "phone": "202-456-1111"
  }
}
```

Instruction example:

```handlebars
{{#if customer.verified}}
- The caller matched customer {{customer.first_name}} {{customer.last_name}}.
- You may address the caller by first name after greeting.
{{else}}
- The caller was not automatically matched. Ask for email or phone and use SearchCustomers if enabled.
{{/if}}
```

### Inbound Without Customer Match

If no customer phone match exists, item details may be absent and `customer.verified` will not be true.

In this case, include `SearchCustomers` if the agent should locate the customer during the call.

Instruction example:

```text
If the caller is not verified, ask for their email or phone number. Use SearchCustomers to find the customer. If a likely customer is found, verify the caller using zip code before discussing account details.
```

---

## Agent Instructions Should Define System Action Rules

Do not just enable system actions. Tell the AI when to use them.

Bad instruction:

```text
Help the customer with their order.
```

Better instruction:

```text
If the caller asks about an order, first confirm the caller is verified. Then use GetCustomer to retrieve the customer record if needed. Use the most relevant sale ID from the customer record with GetSale. Summarize the sale status briefly and do not discuss payment details unless the caller has been verified.
```

---

## Agent Instructions Should Define Limits

For consequential actions, define strict limits.

Examples:

```text
Only process a pending sale if the customer clearly agrees to complete the purchase.
```

```text
Do not process the pending sale more than 2 times during one call.
```

```text
Do not issue refunds unless the caller is verified and the refund reason matches the refund policy.
```

```text
If the caller threatens a chargeback, do not refund. Create a note and transfer or end the call according to escalation policy.
```

---

## Agent Instructions Should Define What to Record

If `CreateNote` or `InsertMetadata` is included, tell the AI exactly what to save.

Example:

```text
At the end of the call, create a note on the customer summarizing the reason for the call, whether the caller was verified, actions taken, and whether human follow-up is needed.
```

Example metadata instructions:

```text
If the customer agrees to retry payment, insert metadata on the sale: `ai_voice_payment_retry_requested = true`.
If the payment retry succeeds, insert metadata on the sale: `ai_voice_payment_retry_success = true`.
If the payment retry fails, insert metadata on the sale: `ai_voice_payment_retry_success = false`.
```

---

# Function Event Data References for AI Voice Agent Use

Use the canonical section above, **“Canonical AI Voice Agent Data Model: Filter Function vs Pre-Agent Function vs Instruction Compile Data,”** as the source of truth for AI Voice Agent Function/input-data references.

Key example-data URLs:

```text
Filter Function input:
https://revcent.com/documentation/files/function/event/filter/[item_type].json

Outbound pre-agent Function input:
https://revcent.com/documentation/files/function/event/pre_agent/outbound/[item_type].json

Outbound instruction compile data:
https://revcent.com/documentation/files/ai_voice_agent/outbound/[item_type].json

Inbound pre-agent Function input with customer match:
https://revcent.com/documentation/files/function/event/pre_agent/inbound/customer_match.json

Inbound pre-agent Function input with no customer match:
https://revcent.com/documentation/files/function/event/pre_agent/inbound/no_customer_match.json

Inbound instruction compile data with customer match:
https://revcent.com/documentation/files/ai_voice_agent/inbound/customer_match.json

Inbound instruction compile data with no customer match:
https://revcent.com/documentation/files/ai_voice_agent/inbound/no_customer_match.json
```

# Output Schema

A successful response returns:

```json
{
  "api_call_id": "XXXXXXXXXXXXXXXXXXXX",
  "api_call_unix": 1740000000,
  "code": 1,
  "ai_voice_agent_id": "XXXXXXXXXXXXXXXXXXXX",
  "result": "..."
}
```

---

# Create Checklist

1. Confirm AI Voice Agent capabilities are enabled.
2. Call `GetUserThirdPartyIntegrations`.
3. Confirm a compatible realtime `ai` user third-party integration exists.
4. Confirm the realtime `ai` integration is configured for OpenAI with a `gpt-realtime-*` model.
5. Confirm a compatible `ai_voice` user third-party integration exists.
6. Confirm the `ai_voice` integration is configured for Twilio with a selected/usable phone number.
7. If the realtime `ai` integration is missing, create it before creating the AI Voice Agent.
8. If the `ai_voice` integration is missing, create it before creating the AI Voice Agent.
9. Save the correct 20-character integration ID for `third_party_integration_ai`.
10. Save the correct 20-character integration ID for `third_party_integration_voice`.
11. Decide `inbound` or `outbound`.
12. Write a clear name and description.
13. Create disabled first.
14. Ask the user for the specific purpose, audience, trigger, call flow, tone, verification rules, allowed actions, prohibited actions, and escalation rules.
15. Draft detailed Markdown instructions specific to the user's use case.
16. Display the drafted instructions to the user for review and edits before creating the AI Voice Agent.
17. Do not create the agent with minimal or generic instructions unless the user explicitly approves proceeding after review.
18. Enable only necessary system actions.
19. Configure limits.
20. Configure active window if needed.
21. For outbound event agents, use specific event notation.
22. For outbound event agents, use delay and filters.
23. Use `max_calls_per_item = 1` unless repeated calls are intentional.
24. Use filter Function only for call eligibility.
25. Use pre-agent Function only for instruction enrichment.
26. Use `TriggerFunction` system action only for live-call Function calls.
27. Confirm both required integration IDs are present in the final `CreateAIVoiceAgent` request.
28. Test before enabling.


---

# Overview Reference

MCP/AI should read the AI Voice Agent overview for broad conceptual understanding:

```text
https://revcent.com/documentation/markdown/mcp/operation/OverviewAIVoiceAgent.md
```


---
Document Parent Directory
* [Operations](https://revcent.com/documentation/markdown/mcp/operation/index.md) - AI/MCP details and overviews for operations available within the RevCent MCP.