Use this planning guide as you plan, build, and implement your custom virtual agent integration with CXone. The guide provides a general overview of the process. The specific requirements and the amount of time each phase takes depends on your unique environment and situation.
The process has five phases:
- Planning phase 1: In this phase, you explore the architecture of your organization's environment. Your goal is to understand the environment and determine the requirements and limitations of your unique situation.
- Planning phase 2: In this phase, you look at your virtual agent provider's requirements. Your goal is to determine how the requirements impact your environment and the integration with CXone. During this phase, you also determine use cases for the virtual agent and plan out the required scripts.
- Development: During this phase you build the proxy tunnel, create the required scripts, and complete any other development identified in the planning phases.
- Testing: During the testing phase, you thoroughly test your custom integration.
- Deployment: During the deployment phase you move the integration into your production environment.
Resources and deliverables are described for each phase below.
There are significant differences in
Planning Phase 1: Architecture
During this phase, your goal is to understand the environment where you'll be building the proxy tunnel. You must:
- Understand the unique architecture of your environment, including API gateways, firewalls, and service layers.
- Understand the architecture of the virtual agent you're using, including:
- API endpoints that CXone needs access to.
- Requirements for connecting to the virtual agent provider API. For example, can you connect using a RESTful solution, or does it require a gRPC
The Google remote procedure call data exchange technology. solution? - Authentication requirements.
- Understand the requirements of the CXone channels A way for contacts to interact with agents or bots. A channel can be voice, email, chat, social media, and so on. that you're using with the virtual agent. For example, if you are setting up a chatbot, you need to understand the requirements of
- Determine the requirements for proxy hosting in your environment, such as using virtual machines or containers. For example, some providers may require a RESTful An interface between two computer systems that allows the secure exchange of data over the internet. solution, while others may need gRPC.
- Determine the failover requirements for the proxy tunnel.
- Define the monitoring needs for the live, production version of the integration.
Deliverables for Planning Phase 1
At the end of this phase, you should have the beginnings of your Technical Design Documentation (TDD), including:
- Architecture diagrams.
- Sequence diagrams.
- Framework and technologies.
- Authorization flow.
- Proxy tunnel hosting strategy.
- Proxy tunnel failover strategy.
- Long-term monitoring plan.
Resources for Planning Phase 1
- Example integration to set up and test.
- Example TDD.
- Architecture best practices.
- Custom AI integration design examples.
- Proxy tunnel design information.
- Sample sequence diagrams.
Planning Phase 2: Virtual Agent
The planning that happens during this phase centers on your virtual agent. The planning needed in this phase will vary depending on whether you're developing a new virtual agent or integrating an existing one. For example, you may need to:
- Define what you want the virtual agent to do and how it will work combined with your live agents and any other bots, virtual agents, or agent assist applications A software application that provides context-specific help to the agent. you use with CXone.
- Identify any high-level constraints on the implementation of the virtual agent in your environment and determine how to address them with CXone and custom Studio scripting.
- Determine which schemas and parameters your integration needs to use for CXone and your virtual agent. The parameters need to be mapped between the two systems.
- Discuss features you require, such as markdown or event transmission.
- Identify the conversational flows and intents you require.
- Map out the flow of the Studio scripts required to integrate your virtual agent with CXone.
- Determine the channel A way for contacts to interact with agents or bots. A channel can be voice, email, chat, social media, and so on. that contacts will use to initiate interactions with your virtual agent. Note if it requires any setup and what the requirements are. For example, if you use CXone chat, you must create a chat profile to define the appearance of the chat window and you need to determine where on your website the chat will be located.
- Determine the CXone ACD skills Used to automate delivery of interactions based on agent skills, abilities, and knowledge, campaigns A grouping of skills used to run reports., and points of contact The entry point that an inbound contact uses to initiate an interaction, such as a phone number or email address. that are required.
- Non-functional requirements, such as:
- Processing time.
- Latency measures to benchmark proxy processing time.
- Memory consumption.
Deliverables for Planning Phase 2
At the end of this phase your TDD should include:
- A list of use cases, intents, and conversational flows for your virtual agent.
- A list of functional and non-functional requirements.
- A link to your Swagger prototype.
- A list of Studio scripts that need to be created, as well as the requirements for each.
- A list of the setup and configuration steps required by the channel you're using with your custom integration.
- A list of skills, campaigns, and points of contact that must be made in CXone.
Resources for Planning Phase 2
- Sample use cases and conversational flows.
- Sample Studio scripts.
- Scripting requirements and guidelines for virtual agent scripts.
- CXone platform configuration requirements for custom virtual agent integrations.
- The CXone custom virtual agent integration Swagger
. - CXone online help for channels:
Development Phase
During the development phase you need to build the required elements of the integration in a test environment. As you build, follow the requirements you documented in your TDD. Specifically, you need to:
- Build the proxy tunnel/webhook according to the plan established in planning phase 1.
- Create the required Studio scripts. Configure and connect all actions. Test and debug the script.
- Build in any required authentication pieces.
- Develop your virtual agent's use cases and intents.
- Implement your failover process.
Deliverables for the Development Phase
At the end of this phase, you will have working versions of the:
- Proxy tunnel, with authentication built in, if required.
- An authentication server set up, if required.
- A working virtual agent, with all required intents and use cases.
- Studio scripts.
- Failover process built out.
Resources for the Development Phase
- Your TDD.
- The Resources page.
- Studio online help for actions, scripting, and debugging.
- The Studio scripting reference guide.
Testing Phase
During the testing phase, perform user acceptance and end-to-end testing of every aspect of the integration, including all use cases. Test previously-identified non-functional requirements. You should also perform failover testing. Resolve bugs as they arise.
Deliverable for the Testing Phase
A working custom virtual agent integration with all issues resolved.
Resources for the Testing Phase
- Implementation steps to follow when setting up the integration in your test environment.
- Online help for tracing, testing, and debugging Studio scripts.
- Studio scripting guide and reference material.
Deployment Phase
When the integration is fully tested and functions as expected in your test environment, you can move it into your production environment. When everything is set up in production, test it to ensure that the system still functions as expected.
After deployment, perform ongoing monitoring of the live integration.
Resources for the Deployment Phase
- Implementation steps to follow when moving the integration into your production environment.