Connected framework for identifying automation candidates

The method includes receiving a process dataset. The process dataset includes data related to a user-executed process. The method also includes automatically mapping the process dataset to multisource system data deemed relevant to automation of the user-executed process. The method also includes detecting a plurality of scenarios in the user-executed process via the automatically mapped process dataset. The method also includes performing scenario-based filtering of the plurality of scenarios. The method also includes automatically generating an automation recommendation for the user-executed process.

BACKGROUND

Technical Field

The present disclosure relates generally to the deployment and utilization of bots for automated tasks and more particularly, but not by way of limitation, to a connected framework for identifying automation candidates.

History of Related Art

Task automation, while often desirable, is not always feasible. Robotic process automation (RPA) platforms have a tendency to provide a framework for automating tasks without providing a streamlined way to determine what should be automated.

SUMMARY

In an embodiment, one general aspect includes a method that is performed by a computer system. The method includes receiving a process dataset. The process dataset includes data related to a user-executed process. The method also includes automatically mapping the process dataset to multisource system data deemed relevant to automation of the user-executed process. The method also includes detecting a plurality of scenarios in the user-executed process via the automatically mapped process dataset. The method also includes performing scenario-based filtering of the plurality of scenarios. The method also includes automatically generating an automation recommendation for the user-executed process. Other embodiments of this aspect include corresponding computer systems, apparatus, and computer programs recorded on one or more computer storage devices, each configured to perform the actions of the methods.

In an embodiment, another general aspect includes a computer system. The computer system includes a processor and memory. The processor and the memory in combination are operable to implement a method. The method includes receiving a process dataset. The process dataset includes data related to a user-executed process. The method also includes automatically mapping the process dataset to multisource system data deemed relevant to automation of the user-executed process. The method also includes detecting a plurality of scenarios in the user-executed process via the automatically mapped process dataset. The method also includes performing scenario-based filtering of the plurality of scenarios. The method also includes automatically generating an automation recommendation for the user-executed process.

In an embodiment, another general aspect includes a computer-program product. The computer-program product includes a non-transitory computer-usable medium having computer-readable program code embodied therein. The computer-readable program code is adapted to be executed to implement a method. The method includes receiving a process dataset. The process dataset includes data related to a user-executed process. The method also includes automatically mapping the process dataset to multisource system data deemed relevant to automation of the user-executed process. The method also includes detecting a plurality of scenarios in the user-executed process via the automatically mapped process dataset. The method also includes performing scenario-based filtering of the plurality of scenarios. The method also includes automatically generating an automation recommendation for the user-executed process.

DETAILED DESCRIPTION

Robotic process automation (RPA) is the use of software, typically in combination with artificial intelligence (AI) and machine learning (ML) capabilities, to handle high-volume sequences of repeatable tasks that previously required humans to perform. These tasks can include interacting with a user interface (UI), for example, to perform queries, calculations, maintenance of records and transactions, web automations, remote operations, database functions, terminal connections, desktop operations, text operations, mouse simulations, keyboard simulations, folder operations, file handlers, clipboard handlers, combinations of the foregoing and/or the like. RPA technology can mimic a human worker, for example, by logging into applications, entering data, calculating and completing tasks, and logging out.

RPA technology is not always part of an organization's information technology (IT) infrastructure, but can instead, sit on top of it, enabling an organization to implement RPA technology quickly and efficiently, without changing the existing infrastructure and systems. In various embodiments, a computing environment can include, for example, many hundreds or thousands of software agents, often referred to herein as “bots,” that automatically perform robotic processes. In various cases, the sequence of computer-implemented tasks performed by each bot can be the same or different, or a combination thereof. Oftentimes, the computing environment can further include, for example, many hundreds or thousands of human workers that likewise execute the same or similar computer-implemented tasks, or a combination thereof, via manual interaction with UIs. A set or sequence of computer-implemented tasks, such as the foregoing example tasks, may be referred to as a user-executed process.

Although bots, potentially in combination with human workers, can provide greater efficiency via increased automation, bots introduce numerous technical problems. For example, even when RPA is implemented for performing some business process, many processes continue to be performed manually. Even when automation takes over business processes, it is uncertain that the technology being used for the automation projects are efficient enough to perform those projects.

In today's competitive world of digital technology, it is more important than ever to utilize more efficient, and hence often complicated, automation systems. Many businesses nowadays adopt to automate internal business operations in order to reduce operating expenses and boost productivity. Automating business processes in the organization may be extremely advantageous, possibly allowing organization to reduce the cost of automated job activities while double their productivity. However, a botched automation project can result in resources being squandered and may prevent businesses from pursuing further automation initiatives for an extended period of time, eventually placing them behind rivals who embrace automation and make it work.

Identifying the right automation opportunity is technically difficult. An automation project's failure is sometimes ascribed to a poor use-case selection, as well as the technological solutions chosen for the initial trial or proof of concept (PoC). Furthermore, the complexity of today's digital world makes manual analysis and processing impractical. Using manual procedures results in sluggish and error-prone results, regardless of the inefficiency associated with it.

In various embodiments, intelligent automation as described herein can overcome obstacles such as those described above. The present disclosure describes examples of an automated system, functioning based on RPA, that can identify potential automation candidate for performing business processes and recommend appropriate technology to perform those business processes in order to achieve a desired outcome. In certain embodiments, an intelligent process automation model and associated method can analyze the business processes and render appropriate recommendations for automating the business processes, for example, by integrating RPA and cognitive automation technologies. Examples will be described below relative to the Drawings.

For purposes of this application, the term “UI” can include, without limitation, any type of human-machine interface. Example UIs include text-based interfaces such as command-line interfaces, conversational interfaces, crossing-based interfaces, direct manipulation interfaces, gesture interfaces, graphical UIs (GUIs), hardware interfaces, holographic UIs, intelligent UIs, motion tracking interfaces, natural-language interfaces, object-oriented UIs, reflexive UIs, touchscreen interfaces, touch UIs, voice UIs, and web-based UIs. Many of the aforementioned UIs accept input via input devices such as a keyboard, mouse, microphone, combinations of the foregoing, and/or the like. Inputs from any of these devices, in possible combination with specific UI objects or components, can be considered examples of UI events. For illustrative purposes, various examples will be described herein relative to GUIs and UI events that are detected or received in relation to GUIs. It should be appreciated, however, that the principles described herein are applicable to any type of UI, inclusive of the example UIs mentioned previously. A user, unless specifically stated otherwise, or otherwise understood within the context as used, can include any entity, including a human or bot, that can interact with a UI.

FIG.1illustrates an example of a system100for implementing a central management system140for user-executed processes. The system100includes the central management system140, tenant systems110, RPA platforms124, user systems160and one or more data stores150, each of which is operable to communicate over a network108. The network108may be, or include, one or more of a private network, a public network, a local or wide area network, a portion of the Internet, combinations of the same, and/or the like.

In some aspects, the central management system140can centrally manage bot deployments on the RPA platforms124for its tenants. The RPA platforms124are shown to include an RPA platform124(1), an RPA platform124(2) and an RPA platform124(N). It should be appreciated that three RPA platforms are shown among the RPA platforms124only for illustrative purposes. In various implementations, any number of RPA platforms can be included among the RPA platforms124. In a typical embodiment, the RPA platforms124each provide RPA software for creating and executing bots, generally using different RPA technology, interfaces and formats.

In particular, in the system100, the tenant systems110can be served by the central management system140. In general, the tenant systems110can each be considered an abstraction of users, inclusive of both bots and human workers, that execute user-executed processes managed by the central management system140, and the systems and data sources with which those users interact. For example, one of the tenant systems110is shown as owned or operated by “Tenant A” while another system110is owned or operated by a different tenant, “Tenant B.” The tenant systems110shown can be owned or operated by the same or different entities. For example, Tenants A and B can represent customers (e.g., entities such as companies or individuals) of an operator of the central management system140. Although the term “tenant” is used herein to describe the tenant systems110or owners/operators thereof, in addition to having its ordinary meaning, the term “tenant” can, but need not, refer to tenancy in a multitenant software architecture.

The tenant systems110are each shown to include one or more managed bots120, one or more managed human workers123, one or more computer systems122, one or more customer experience (CX) systems125, and one or more data sources121. The one or more computer systems122can each provide a computing environment, inclusive of applications and corresponding UIs and dashboards, for executing configurable tasks. As illustrated, any given one of the computer systems122may be operated by one of the managed bots120or one of the human workers123. In some cases, the computer systems122may represent desktop virtualization environments. In such cases, the human workers123, for example, may operate the user systems160and access the desktop virtualization environments over the network108.

The CX systems125can include a plurality of different communication systems and channels with which the managed human workers123and/or the managed bots120interact to perform their respective functions, which may include, for example, providing support to one or more supported users in the capacity of support agent. The CX systems125can facilitate, for example, voice communication (e.g., audio potentially in combination with video) and store recordings of the voice communication. The voice communication can be, for example, voice messages, two- or multi-way conversations between or among one or more of the managed bots120, one or more of the managed human workers123, and/or one or more users requesting support. In addition, or alternatively, the CX systems125can facilitate non-voice communication such as emails, support tickets, chat communications, chatbot communications, messaging via any suitable messaging service, combinations of the foregoing and/or the like.

The one or more data sources121of each of the tenant systems110can include data streams or datasets that can be received or processed by the computer systems122, potentially as part of executing the configurable tasks. In various cases, the one or more data sources121can be updated by the computer systems122, or other components, in real-time, on a periodic basis, e.g., according to a schedule, on-demand or a combination of the same. In various cases, the tasks for which the computer systems122are configured can be executed in the respective computing environments, for example, manually by the human workers123and/or robotically by the managed bots120. In a typical embodiment, the managed bots120are each deployed on an RPA platform of the RPA platforms124and interact as users in the computing environments of the computer systems122for purposes executing some or all of the configurable tasks as robotic processes.

The managed bots120can each include an instruction set126that can be used to provide the managed bots120a complete set of all computer-implemented tasks or steps that are to be performed in sequence automatically by the managed bots120, for example, as a user-executed process. In some embodiments, the instruction set126is in a machine-readable code that can be recognized and executed by a central processing unit. In various embodiments, the instruction set126can be made up of, for example, a markup language, a low-level programming language, a high-level programming language, a scripting language, a machine language, an assembly language or any combination thereof.

As illustrated, the computer systems122can include calibration agents130. The calibration agents130are software agents that can be used to facilitate automated creation of some or all of the managed bots120. In certain embodiments, the calibration agents130can be individually triggered, for example, by a human user of one of the user systems160, to monitor and record user activity in the computing environments provided by the computer systems122. The user activity can represent, for example, user-executed processes in the computing environments. The user activity can include, for example, UI activity.

In the illustrated embodiment, the central management system140can include a calibration processor142, a bot creation module143, a bot deployment module144, a bot manager145, a reporting module146, a business process manager147, a cognitive automation manager148, a CX automation manager149, a workforce manager151, an IT manager155, and a process automation advisor157. Each of these components can be implemented with hardware and/or software, including (optionally) virtual machines and containers. In an example, the central management system140can be implemented as a single management server. In another example, the central management system140can be implemented in a plurality of virtual or physical servers, which may or may not be geographically co-located. In some embodiments, the central management system140and/or other aspects of the system100may be hosted on a cloud-provider system.

In certain embodiments, features of the components of the central management system140can be made accessible over an interface to the user systems160. The user systems160can include any type of computing device, including desktops, laptops, tablets, and smartphones, to name a few. The user systems160can be operated by users, such as the human workers123, or by other users, for example, for administration purposes.

The calibration processor142can, for each of the tenant systems110, in collaboration with the calibration agents130, monitor execution of user-executed processes by the managed bots120and/or the human workers123. Operation of the calibration processor142and the calibration agents130will be described in greater detail relative toFIG.2.

The bot creation module143can be utilized to create bots such as, for example, the managed bots120. In some embodiments, an instruction set is created via the bot creation module143that contains all of the instructions and/or modules for a specific type of bot. The instruction set that is created can be similar to the instruction set126of each of the managed bots120. In certain embodiments, the bot creation module143can utilize information from the calibration processor142and/or the process automation advisor157, for example, to automatically create each instruction set. In some embodiments, the bot creation module143includes or provides a configuration interface for manual creation of an instruction set, or for revision or tuning of an automatically created instruction set. The configuration interface can be accessible, for example, by the user systems160.

In certain embodiments, the bot deployment module144can be utilized to deploy a bot on the RPA platforms124for a tenant, such that the deployed bot becomes one of the managed bots120. In various embodiments, the bot deployment module144can utilize an instruction set created by the bot creation module143that can then be deployed. For example, the instruction set126of one of the managed bots120could be representative of a bot created by the bot creation module143and then deployed via the bot deployment module144. In certain embodiments, the bot deployment module144can be used to deploy a single bot and/or a plurality of bots concurrently. In many cases, the bot deployment module144can be utilized to deploy bots on a variety of the RPA platforms124. In some embodiments, the bot deployment module144can publish a configuration interface to the user systems160, for example, for administrators, super users or other users (e.g., of a particular tenant) to select or specify such commands. In other embodiments, the bot deployment module144executes an automatic process to deploys bots without manual interaction. In various embodiments, the bot deployment module144can store command sets for some or all of the RPA platforms124.

The bot manager145can serve to manage bots such as, for example, the managed bots120, for tenants. In certain embodiments, the bot manager145can issue commands to control operation of bots. The bot manager145can be utilized to re-configure, optimize and/or customize any of the managed bots120. For example, various commands can start or stop bots, perform configuration management, combinations of the same and/or the like. In some cases, the bot manager145can publish a configuration interface to the user systems160, for example, for administrators, super users or other users (e.g., of a particular tenant) to select or specify such commands.

The reporting module146can generate regular or on-demand reports related to the managed bots120and the managed human workers123. In various cases, these reports can provide a snapshot of some or all of the managed bots120and the managed human workers123(e.g., regarding performance gaps as described further below). The reporting module146can publish reports or other generated information, for example, to a webpage, user dashboard, and/or the like. The reporting module146can generate and execute a query of the one or more data stores150, as appropriate. The web page, user dashboard or other UI(s) output, for example, by the reporting module146, can be accessed by certain users of the user systems160.

The business process manager147includes tools and interfaces to manage business processes in the system100, inclusive of user-executed processes. For example, the business process manager147can maintain, for the tenant systems110, business process specifications as a series of tasks, dependencies between business processes, combinations of the foregoing and/or the like.

The cognitive automation manager148can orchestrate cognitive automation in the system100, for example, as may be implemented by the managed bots120. In various embodiments, the cognitive automation manager148can manage, track, and/or implement some or all instances of intelligent process automation that are used by or with respect to the tenant systems110. In certain embodiments, the cognitive automation manager148, in combination with other elements of the system100, utilizes continuous learning, automatic recommendations, and automatic scoring and decision-making features to optimize ML technologies for process automation.

The CX automation manager149can orchestrate and manage the CX systems125of the tenant systems110. In certain embodiments, the CX automation manager149collects granular data regarding utilization of the CX systems125, including details of interactions that take place using the CX systems125. In addition, or alternatively, the CX automation manager149can control operation of the CX systems125. The workforce manager151can include one or more workforce management systems that are used to manage, control, and track, for example, the managed human workers123for each of the tenant systems110. The IT manager155can include software and interfaces for managing, controlling, and tracking, for example, the computer systems122.

The process automation advisor157can, for each of the tenant systems110, in collaboration with the calibration agents130, monitor execution of user-executed processes by the managed bots120and/or the human workers123. In various embodiments the process automation advisor157integrates data from numerous data sources, such as various components of the tenant systems110and/or the central management system140, to facilitate automation of user-executed processes. Operation of the process automation advisor157and the calibration agents130will be described in greater detail relative toFIGS.3-5.

In general, the one or more data stores150can include any information collected, stored or used by the central management system140. For example, in various embodiments, the one or more data stores150can include instruction sets for bots, command sets for one or more of the RPA platforms124, deployment settings for bots (e.g., on a tenant-specific and/or bot-specific basis), metadata for bots to be deployed, data collected from the managed bots120, the human workers123, the computer systems122or the CX systems125, combinations of the same and/or the like. In certain embodiments, data stored in the one or more data stores150can take the form of repositories, flat files, databases, etc. In certain embodiments, the one or more data stores150can be utilized as an event library, in which actions performed by any of the managed bots120and/or the user systems160are stored. The event library can also contain business rule libraries, exception libraries, control libraries, keyboard libraries, database libraries and/or cognitive libraries.

FIG.2illustrates an example of an environment200for a calibration system252for a user-executed process. Although the environment200is described relative to a single user-executed process for illustrative purposes, it should be appreciated that the system100ofFIG.1, for example, can support a plurality of such environments for a plurality of user-executed processes. The environment200includes the calibration system252, a knowledge management system270, calibration agents230, a calibration processor242and user environments222.

The user environments222can correspond to user environments provided, for example, by the computer systems122ofFIG.1. As illustrated, the user environments222include bot environments276, human-worker environments278, and lead-user environments280. The bot environments276are generally operated by bots such as the managed bots120ofFIG.1The human-worker environments278are generally operated by human workers such as the managed human workers123ofFIG.1.

In general, the lead-user environments280are a subset of the user environments222that serve, for example, as a basis for incremental learning. In some embodiments, the lead-user environments280can include, for example, a subset of the human-worker environments278corresponding to specific human workers who have been designated as such, for example, due to their human expertise. However, generally speaking, the lead-user environments280can include some or all of the bot environments276, some or all of the human-worker environments278, or a selected combination of certain of the bot environments276and certain of the human-worker environments278.

The calibration system252is configured to calibrate different types of users, such as the managed bots120and the managed human workers123ofFIG.1, for execution of the user-executed process. The calibration system252includes an ingestion module253, a UI listener254, a data transformer256, a data classifier258, a learning module260, a real-time process optimizer262, and a process change administrator264. As illustrated, in various embodiments, operation of the calibration system252can be distributed between the calibration agents130and the calibration processor142in any suitable fashion. In general, the calibration agents230and the calibration processor242can each operate as described relative to the calibration agents130and the calibration processor142, respectively, ofFIG.1.

The knowledge management system270can include data related to how the user-executed process is executed. In various examples, the knowledge management system270can include, for example, process documents, knowledge base files, system alerts, on-screen tips, bite-sized training materials and/or help files in video, audio, image and document formats. The data of the knowledge management system270can be received or retrieved from other users (e.g., bots and/or human workers) and/or from systems used for training, for example, new human workers. Document formats can include, for example, one or more of Portable Document Format (PDF), Microsoft (MS) Office formats including MS Word, MS PowerPoint (PPT) and MS Excel, and image formats including Joint Photographic Experts Group (JPEG), Portable Network Graphics (PNG) and Graphic Interchange Format (GIF). The knowledge management system270can be stored, for example, in the one or more data stores150ofFIG.1.

The ingestion module253is operable to collect, or ingest, the data of the knowledge management system270. In various embodiments, the data can be indexed and stored, for example, in a data store265. As will be described in greater detail below, the collected or ingested data from the knowledge management system270can be used, in part, to execute machine learning relative to the user-executed process. In various embodiments, the machine learning, once complete, can reduce or eliminate a need for users to directly access and refer to documents or other data in the knowledge management system270.

The UI listener254monitors and records UI activity in the user environments222. For example, the UI listener254can periodically or continuously receive a live screen output of each of the user environments222and record UI activity data based thereon. In certain embodiments, the live screen output can include, for example, one or more UIs that present a data-entry screen for users to perform data entry.

In various embodiments, a given data-entry screen may be, or be included as part of, a text terminal, a browser window, a container window that encloses other windows or widgets, message windows or dialog boxes, a child window opening as a result of user activity in a parent window (e.g., a popup window), a combination of the foregoing and/or the like. Each data-entry screen can include, for example, various control elements with which a user interacts to perform data entry. These control elements can include, for example, radio buttons, check boxes, toggle switches, sliders, list boxes, spinners that step through ranges of values, drop-down lists, menus, menu bars, toolbars, ribbons, text boxes, combo boxes (e.g., combining drop-down list or list box and a text box), icons, tables, tabs, scrollbars, any other suitable UI feature, combinations of the foregoing and/or the like. Some or all of these control elements may be associated, for example, with text labels or graphical icons, depending on a type of interface.

In an example, the UI listener254can use image-recognition technology, optical character recognition (OCR) technology and/or the like to identify individual control elements of the type described above along with specific data entered thereby (e.g., selections, text entries, or the like). The UI listener254can further identify a location of each individual control element within each UI (e.g., using coordinates). According to this example, the UI listener254can generate and/or record, for example, data related to the individual control elements, including data entered thereby and their location within each UI.

In another example, the UI listener254can detect UI events in a given UI in relation to the live screen output. As described previously, the UI events can correspond to input from various input devices such as a keyboard, mouse, microphone, touchscreen, combinations of the foregoing and/or the like. Thereafter, the UI listener254can determine target application(s) for each detected UI event(s). Generally, the target application(s) are executing in a respective computing environment and provide at least part of a UI with which a given user interacts. The target application(s) may include, for example, an application to which the detected UI event(s) are directed, for example, as a result of being in focus or as a result of providing a UI object, component or control element to which the detected UI event(s) relate. Examples include, but are not limited to, an application that provided a text box for receiving text (keyboard event) and an application that is clicked (mouse click event).

The data transformer256can transform data obtained or collected by the ingestion module253and/or the UI listener254. In certain embodiments, the ingestion module253and/or the UI listener254collects various data of the type above, which data may be referred to generically as heterogeneous transaction data. Such heterogeneous transaction data may exist or be compiled in different formats. In various embodiments, the data transformer256can homogenize such data into homogeneous transaction data. For example, with reference to the data produced by the UI listener254, the information related to the individual control elements can be resolved to specific data fields to which the control elements relate (e.g., with a homogenized data-field name and value format). The previously mentioned locations of such control elements can thereby refer to locations of these data fields, sometimes referred to herein as data-field locations. Continuing this example, in certain embodiments, the data transformer256can create a dataset representing the live screen output and/or a UI therein, where the dataset represents the homogeneous transaction data. In some cases, the dataset can be in a structured format that is represented, for example, using XML.

The data classifier258classifies, using a machine learning algorithm, the homogeneous transaction data based on various parameters such as, for example, data fields and values. In various cases, the data classifier258can classify using, for example, artificial neural networks, decision trees, ensemble learning, and/or the like. The classified data can be stored, for example, in the data store265.

The learning module260can initially create a plurality of machine-learning models based on an initial set of classified data, where each machine-learning model can correspond to a specific target UI, a user-executed process, and/or a step or task of a user-executed process. Thereafter, the learning module260can facilitate incremental learning based on new classified data from the data classifier258. For example, the learning module260can select a target UI or process steps for the new classified data and provide the new classified data as input data for the corresponding machine-learning model(s). In various embodiments, the learning module260can thereby learn and associate UI data with specific steps or tasks of the user executed process as represented, for example, in an instruction set similar to the instruction set126ofFIG.1. For each machine-learning model, the learning module260can evaluate readiness to assist in process optimization, for example, through an evaluation of confidence threshold or the like. In various embodiments, the learning module260can restrict learning, for example, to classified data originating from user activity in the lead-user environments280.

The real-time process optimizer262uses the plurality of machine-learning models of the learning module260to monitor execution of the user-executed process in the user environments222. In some aspects, the real-time process optimizer262continuously or periodically receives new classified data for individual user environments of the user environments222as real-time UI activity data. The real-time process optimizer262uses the real-time activity data to track process execution, identify process discrepancies, and provide process guidance. In various embodiments, the real-time process optimizer262can execute functionality for individual ones of the user environments222and/or on an aggregate level across all of the user environments222or any subset thereof.

In various embodiments, with respect to tracking process execution for an individual user environment, the real-time process optimizer262can correlate the real-time UI activity data to a plurality of steps of the user-executed process as represented, for example, in an instruction set similar to the instruction set126ofFIG.1. In an example, the real-time process optimizer262can compare the real-time UI activity data to UI data associated with the plurality of steps of the user-executed process, match the real-time UI activity data to one or more steps of the user-executed process, and update a tracking status of the user-executed process (e.g., which step or task has been completed or is currently being executed).

In various embodiments, with respect to identifying process discrepancies, the real-time process optimizer262can identify anomalies in the real-time UI activity data as process discrepancies. In general, a process discrepancy can be any UI activity data or process performance that is anomalous or irregular for the user-executed process, for example, based on a machine-learning model, rules, or other logic for the user-executed process. Irregularity can be determined in any suitable fashion such as based on a confidence score or other metric. In some embodiments, the real-time process optimizer262can identify missed steps by detecting that one or more tasks steps have been, or are being, performed, while one or more prior steps or tasks have not been performed. The one or more prior steps can be considered missed steps.

In various embodiments, the real-time process optimizer262can detect a process discrepancy as a new process scenario for triggering change management. In various embodiments, a new process scenario can be any detected situation that changes how the user-executed process is performed. In some cases, the real-time process optimizer262can detect a UI change as a new process scenario. For example, as mentioned previously, the real-time process optimizer262can compare the real-time UI activity data to UI data associated with the plurality of steps of the user-executed process and match the real-time UI activity data to one or more steps of the user-executed process. In some embodiments, the real-time process optimizer262can thereafter determine that the UI for a particular step has changed, for example, as a result of not having the same control elements in the same locations within the UI as compared to the UI data associated with the particular step. In an example, a particular data field, such as a password data field, may have been relocated within the UI. According to this example, the UI change embodied by the relocated data field can be detected as a new process scenario. In some embodiments, a given UI change may not be detected as a new process scenario until such change is identified in a threshold number of user environments and/or a threshold number of times.

In some cases, the real-time process optimizer262can detect a change to the user-executed process itself as a new process scenario. For example, as mentioned previously, the real-time process optimizer262can detect process irregularity, for example, specific user environments, such as in the lead-user environments280, as a new process scenario. In an example, a task or other user action that does not match to a step of the user-executed process may be detected as a new step. In another example, a task or other user action that appears to be performed out of order may be detected as a step reordering. In yet another example, a new UI for which the UI activity data does not match to any step of the user-executed process may be detected as a new or added step or series of steps. In still another example, a task or step that is no longer performed may be detected as a step that may be omitted or deleted. In some embodiments, a given change to the user-executed process may not be detected as a new process scenario until such change is identified in a threshold number of user environments and/or a threshold number of times.

In various embodiments, with respect to providing process guidance, the real-time process optimizer262can generate a recommended next step or other recommendation, for example, based on a machine-learning model for the user-executed process. The recommended next step or other recommendation can be determined based on a confidence score or other metric. In some embodiments, the next step or recommendation can be presented in a respective user environment of the user environments222. In another example, the real-time process optimizer262can validate, for example, user input in data fields. The validation can be performed based on a confidence score or other metric. Failed validation can be indicated, for example, as an error in the respective user environment of the user environments222. In various embodiments, real-time process-guidance functionality can be particularly advantageous for human workers such as the managed human workers123ofFIG.1. In certain embodiments, the need to access the knowledge management system270can be reduced or eliminated.

As mentioned above, in various embodiments, the real-time process optimizer262can execute functionality on an aggregate level across all of the user environments222or any subset thereof, where all data used or generated thereby can be stored in the data store265. In certain embodiments, performance of the user-executed process by different users and sets of users can be compared for purposes of identifying performance gaps. Performance can be measured based on any suitable metric such as, for example, errors, process discrepancies, time to complete a transaction (e.g., in terms of mean, median, or the like), total number of completed transactions, a composite of the foregoing and/or the like. In various embodiments, performance can be measured for a user or for a set of users. According to this example, such performance can be compared to a baseline, where sufficient deviation from the baseline constitutes a performance gap. In an example, the baseline can be a predefined baseline with threshold values for the performance under consideration. In another example, the baseline can be a statistical baseline that is compiled across all users or for a particular set of users such as, for example, lead users operating the lead-user environments280, bots operating the bot environments276, human workers operating the human-worker environments278, and/or the like. In various embodiments, performance gaps can be identified for individual users relative to the lead users, bots relative to the lead users, human workers relative to bots, and/or the like.

The process change administrator264can interact with the real-time process optimizer262and/or other components to automatically address new process scenarios. In various embodiments, the process change administrator264can determine, as appropriate, new bot logic for the new process scenario and cause the new bot logic to be implemented, for example, by the managed bots120which execute the user-executed process. The new bot logic can be, for example, an update to the instruction set for the user-executed process. In an example, the process change administrator264can indicate a new location of a particular data field such as a password data field. In another example, the process change administrator264can add a new step such as, for example, clicking a “next” button that was not previously present. In yet another example, the process change administrator264can reorder steps represented in the instruction set. In various embodiments, process change administrator264can update the bots with the new bot logic, for example, by automatically creating an updated version of the same bots (or creating new bots) and deploying or re-deploying such bots.

The calibration agents230can execute in the user environments222and can include a learning agent272and an active agent274. In various embodiments, the learning agent272of the calibration agents230can include agent-level functionality related to learning (e.g., agent-level functionality of the UI listener254and the learning module260). In various embodiments, the active agent274of the calibration agents230can include agent-level functionality related to process optimization (e.g., agent-level functionality of the real-time process optimizer262). The active agent274can provide notifications, for example, in the form of popups, dashboard updates, or the like. Such notifications can relate, for example, to process discrepancies, errors, recommendations, failed validations, or the like as described above relative to the real-time process optimizer262.

FIG.3illustrates an example of the process automation advisor157. Although the process automation advisor157is described relative to a single user-executed process for illustrative purposes, it should be appreciated that the system100ofFIG.1, for example, can support a plurality of such environments for a plurality of user-executed processes. The process automation advisor157includes a hybrid dataset generator301, a ML-based analysis engine304, and a scenario analyzer315.

The hybrid dataset generator301includes an automatic collector302and a manual collector303. In various embodiments, the automatic collector302and the manual collector303can operate individually, or in combination, to generate a business process dataset related to a user-executed process. The business process dataset can include information describing a user-executed process such as, for example, identification of a plurality of steps that are performed as part of the user-executed process, data describing how the user-executed process is executed (e.g., technical documentation), data sources that are accessed in each step of the user-executed process, applications and UIs of the application that are used in each step of the user-executed process, other data related to a user-executed process such as the data described herein, combinations of the foregoing and/or the like. In some cases, the level of detail regarding the plurality of steps can be similar to that of the instruction set126ofFIG.1.

In various embodiments, the automatic collector302generates the business process dataset, at least in part, using the calibration system252. In some embodiments, the automatic collector302can trigger the calibration system252to generate any data the system is operable to produce. In this way, the automatic collector302can receive, or retrieve, any data accessed, generated, or stored by the calibration system252relative to the user-executed process. For example, the automatic collector302can retrieve, or receive, ingested data from the knowledge management system270that describes the user-executed process. In another example, the automatic collector302can retrieve, or receive, recorded UI activity data that has been automatically correlated to a plurality of identified steps of the user-executed process. The recorded UI activity data can include, for example, data related to detected UI events, target applications for the detected UI events, UI objects, components or control elements to which each detected UI event relates, and/or the like. In other examples, the automatic collector302can receive or retrieve, for the user-executed process, homogenous transaction data, classified homogenous transaction data, or any other data related to the user-executed process that is available to the calibration processor142. In some embodiments, the automatic collector302can collect some or all of the data by decoding an augmented shareable video file for the user-executed process as described in U.S. Pat. No. 10,817,314, where any information decoded from such file, such as UI metadata, can serve as part of the business process dataset. U.S. Pat. No. 10,817,314 is hereby incorporated by reference.

In various embodiments, the manual collector303can generate the business process dataset, at least in part, via interaction with an administrator, super user, or other user. For example, in some embodiments, the manual collector303solicits and receives at least a portion of the business process dataset using a web form or similar method. In some embodiments, the manual collector303can be used to fill information gaps, for example, due to some information not being available for automatic generation by the automatic collector302. For instance, in some embodiments, the manual collector303can solicit and receive information regarding locations of data sources that are used in the user-executed process.

In general, the business process dataset generated by the hybrid dataset generator301can include all or any subset of the example data mentioned above. The business process dataset can also include additional data that will be apparent to one skilled in the art after a detailed review of the present disclosure. It should be appreciated that, in various embodiments, the business process dataset can be generated entirely automatically by the automatic collector302, entirely non-automatically by the manual collector303, or part automatically and part non-automatically via a configurable combination of the automatic collector302and the manual collector303.

The ML-based analysis engine304automatically maps the business process dataset produced by the hybrid dataset generator301to multisource system data that is retrieved from a variety of sources. In the illustrated embodiment, the ML-based analysis engine includes a process analyzer305, a productivity analyzer306, a workforce analyzer307, an underlying application analyzer309, an insource/outsource analyzer311, a standard operating procedure (SOP) analyzer312, an environment analyzer313, and a risk analyzer314. As described in greater detail below, the multisource system data to which the business process dataset is mapped can include, for example, preexisting datasets used by the foregoing modules.

Still referring to the ML-based analysis engine304, the underlying application analyzer309can perform, for example, application touchpoint analysis, application downtime analysis, application environment analysis, and/or application stability analysis. The insource/outsource analyzer311can perform, for example, data input and output analysis, information analysis, and/or storage analysis. The SOP analyzer312can perform, for example, process SOP assessment, and/or Suppliers, Inputs, Process, Outputs and Customer (SIPOC) analysis. The environment analyzer313can perform, for example, server environment analysis, latency analysis, and/or downtime analysis. The risk analyzer314can perform, for example, negative scenario analysis, issue analysis, data security analysis, password policy analysis and/or preexisting issue analysis.

In various embodiments, the modules of the ML-based analysis engine304can each have one or more preexisting datasets they work with or use for a given analysis, where such preexisting datasets, in a typical embodiment, are not particular to the user-executed process at issue. The preexisting datasets can be very large and, depending on the specific module, can include, for example, workforce management data, application data repositories, CX automation data, cognitive automation data, general business process data, bot data, other data, and/or the like. In such embodiments, each module of the ML-based analysis engine304can perform its functionality via one or more ML models. For each module, the ML model(s) are trained to receive a business process dataset, determine relevant data within the preexisting datasets that it works with (e.g., using any suitable relevance thresholds), and then perform one or more specific types of analysis using that relevant data. In this way, the modules of the ML-based analysis engine304can each automatically map the business process dataset to its respective preexisting datasets, and the mapping can result in, and be evidenced by, specific analytical data, depending on module type, that ties the business process dataset to the preexisting datasets. Generally, this specific analytical data would not otherwise be relatable to either the business process dataset or the user-executed process at issue because it is stored and maintained by a discrete system or component that exists independently.

The scenario analyzer315includes a scenario detector316, a scenario-based filtering engine317, an automation decision engine318, a use case library319, and a results datastore327. The use case library319can specify a set of defined uses cases that, in various instances, can be performed as all or part of user-executed processes. In general, the use case library319provides at least some information relevant to automation decisions for the same or similar use cases. In various embodiments, the use case library319can represent common use cases for a tenant, common uses cases across multiple tenants, use cases that are generally common in industry or in a subset of industry, combinations of the foregoing and/or the like. For example, the use case library319can identify use cases for which prior automation decisions have been made, such as prior decisions to automate, prior decisions to partially automate and/or prior decisions not to automate, etc. In various embodiments, the use case library319streamlines its use in scenario detection by storing use case data that is structured or formatted similarly to business process datasets and/or mapped business process datasets as described above.

The scenario detector316can leverage the use case library319to detect one or more scenarios, also referred herein as use cases, that are represented in the mapped business process dataset. In some embodiments, the business process dataset and/or the automatically mapped business process dataset can be formatted or structured in a standardized manner to facilitate matching of the same to use cases of the use case library319. In some embodiments, the scenario detector316can perform its detection functionality via an ML model that is trained to match business process datasets and/or mapped business process datasets to the use case library319. It should be appreciated that the user-executed process can include one scenario or multiple scenarios.

Still referring to the scenario detector316and the use case library319, in some embodiments, configurable use-case signatures can be generated and/or used to facilitate comparison. The use-case signature can include any data related to a use case, such as any of the data described above relative to the business process dataset or the mapped business process dataset. For example, certain data fields (e.g., application, combination of applications, user type, etc.) can be established as a signature definition for a use case represented in the business process dataset and the mapped business process dataset. In similar fashion, the same certain data fields can be used to represent the use cases of the use case library319. Thus, in various embodiments, a match can be determined between the user-executed process under analysis and one or more use cases of the use case library319whenever configurable matching criteria is satisfied. The configurable matching criteria can be specified, for example, in terms of number of field matches or a percentage of field matches. In addition, or alternatively, the configurable matching criteria can require that certain fields or certain combinations of fields match or sufficiently match. It should be appreciated that the foregoing matching example is presented only for simplicity of illustration and that numerous other scenario-detection methods are likewise contemplated. Such methods will be apparent to one skilled in the art after a detailed review of the present disclosure.

The scenario-based filtering engine317can perform scenario-based filtering based, at least in part, on identified use cases. In some embodiments, the scenario-based filtering engine317can operate by analyzing, for example, data related to an application or applications that are utilized in the user-executed process under analysis. In some embodiments, the scenario-based filtering engine317can perform collaborative filtering and/or relational filtering. In certain embodiments, the scenario-based filtering engine317can output a filtered scenario set, which set can include all scenarios or any subset of the scenarios detected by the scenario detector316.

In some embodiments, the scenario-based filtering engine317provides a personalized recommendation based on business processes or accounts. The scenario-based filtering engine317employs similarities in the scenarios that were the result obtained through data such as, but not limited to, previous iterations, information accumulated pertaining to business/process, and the like, to generate or make recommendations. The scenario-based filtering engine317also provides personalized recommendations based on the user preferences and similar scenarios, thereby offering better recommendations to a process.

In an example recommendation scenario, the scenario-based filtering engine317recommends a process scenario to a user based on a determined similarity with another business or process. Apart from predefined parameters such as, but not limited to, business, industry, process type, and the like, a business profile may indicate prior scenarios as process1, process2, process n, etc. In some embodiments, an automation recommendation may suggest similar processes and/or automation candidates for a new business based on parameters or attributes such as the forgoing. In the aforesaid example, the user would expect recommendations for similar automation candidates, but process similarity for a specific account may be something they did not expect yet appreciate.

The automation decision engine318can generate one or more automation candidates relative to the user-executed process. In some embodiments, the automation candidates can correspond to any detected scenarios from the use case library319that remain after filtering by the scenario-based filtering engine317. In other embodiments, the automation decision engine318can receive the filtered scenario set from the scenario-based filtering engine317and execute logic to determine whether automation is recommended. In some embodiments, the automation decision engine318can perform its decision functionality via an ML model that is trained to receive the filtered scenario set and produce one or more automation recommendations. The automation recommendations can include recommendations to automate all or a portion of the user-executed process. In some embodiments, the automation recommendations can include recommendations not to automate all or a portion of the user-executed process. Automation recommendations can include, for example, identification of specific technologies such as, for example, a CX automation platform, an RPA platform, etc. Results produced by the automation decision engine318and/or any other module of process automation advisor157can be stored in the results datastore327or in other memory.

In some embodiments, the automation decision engine318can publish its recommendations to an administrator or other user. In some of these embodiments, if the administrator or other user accepts the recommendation, the ML model of the automation decision engine318, if applicable, can be updated based on the recommendation, thereby using the recommendation as training data. In some embodiments, the automation decision engine318can automatically implement the recommendation, either with or without user acceptance of the recommendation, depending on system configuration, for example, by automatically creating and deploying one or more bots having instruction sets corresponding to the user-executed process.

FIG.4illustrates an example400of various components shown inFIGS.1-3. In the example400, the hybrid dataset generator301generates a business process dataset468as described relative toFIG.3. Also as described relative toFIG.3, the business process dataset486is automatically mapped to multisource system data that is retrieved from a variety of sources, where the multisource system data can include, at least in part, preexisting datasets used by those sources. For example, as shown inFIG.4, the multisource system data can include framework data469and enterprise application metadata482.

According to the example ofFIG.4, the framework data469can be retrieved and/or derived from, for example, preexisting datasets maintained or used by framework data sources466that include the bot manager145, the business process manager147, the cognitive automation manager148, and the CX automation manager149. In similar fashion, the enterprise application metadata482can retrieved and/or derived from, for example, preexisting datasets maintained or used by the IT manager155. The preexisting datasets maintained or used by the IT manager155can relate to each application or technology managed by the IT manager155, or any subset thereof. The automatic mapping of the business process dataset486to the framework data469and the enterprise application metadata482can yield, for example, mapped business process dataset486.

Still referring toFIG.4, as described relative toFIG.3, the mapped business process dataset486, in combination with the use case library319, can be used to detect scenarios, or use cases, for the user-executed process under analysis. Further, the enterprise application metadata482, which can include data regarding applications that are relied upon in a given scenario or use case, can be used as application context data492during scenario filtering. More particularly, scenario-based filtering can be performed such that, for example, scenarios488result from scenario-based collaborative filtering and scenarios490result from scenario-based relational filtering. In various embodiments, the scenarios488and the scenarios490can collectively represent a filtered scenario set that is used to produce one or more automation recommendations484. The automation recommendations484can each relate, for example, to a scenario or use case for which automation is recommended (or not recommended).

FIG.5illustrates an example of a process500for operating the process automation advisor157ofFIGS.1and3. In certain embodiments, the process400can be implemented by any system that can process data. Although any number of systems, in whole or in part, can implement the process400, to simplify discussion, the process300will be described in relation to particular components shown and described relative toFIGS.1-4.

At block502, the hybrid dataset generator301generates a business process dataset relating to a user-executed process. In a typical embodiment, the user-executed process relates a process performed, at least in part, by one or more of the human workers123, although that need not be the case. In some embodiments, for example, the process500may be used to evaluate an appropriateness of existing automation. At block504, the ML-based analysis engine304automatically maps the business process dataset to multisource system data such as multisource system data that is retrieved from preexisting datasets maintained by variety of sources. The block504can yield a mapped business process dataset as described relative toFIGS.3and4.

At block506, the scenario detector316detects scenarios, or use cases, represented in the mapped business process dataset. At block508, the scenario-based filtering engine317executes scenario-based filtering of the detected scenarios to yield, for example, a filtered scenario set. At block510, the automation decision engine318generates one or more automation recommendations based on the filtered scenario set. At block512, the automation decision engine318provides the one or more recommendations to a user or administrator. At decision block514, the automation decision engine318determines whether the user or administrator has accepted any of the one or more recommendations. If not, the process500ends. Otherwise, if it is determined, at the decision block514, that the user or administrator has accepted any of the one or more recommendations, at block516, the ML model with which the automation decision engine318is configured, if any, is updated based on the accepted recommendation(s), thereby using the accepted recommendation(s) as training data. After block516, the process500ends.

FIG.6illustrates an example of a computer system600that, in some cases, can be representative, for example, of the central management system140, the RPA platforms124, the tenant systems110, the user systems160and/or a module or sub-component of the foregoing. The computer system600includes an application622operable to execute on computer resources602. The application622can be, for example, any of the systems or modules illustrated inFIG.1orFIG.2. In particular embodiments, the computer system600may perform one or more steps of one or more methods described or illustrated herein. In particular embodiments, one or more computer systems may provide functionality described or illustrated herein. In particular embodiments, encoded software running on one or more computer systems may perform one or more steps of one or more methods described or illustrated herein or provide functionality described or illustrated herein.

The components of the computer system600may comprise any suitable physical form, configuration, number, type and/or layout. As an example, and not by way of limitation, the computer system600may comprise an embedded computer system, a system-on-chip (SOC), a single-board computer system (SBC) (such as, for example, a computer-on-module (COM) or system-on-module (SOM)), a desktop computer system, a laptop or notebook computer system, an interactive kiosk, a mainframe, a mesh of computer systems, a mobile telephone, a personal digital assistant (PDA), a wearable or body-borne computer, a server, or a combination of two or more of these. Where appropriate, the computer system600may include one or more computer systems; be unitary or distributed; span multiple locations; span multiple machines; or reside in a cloud, which may include one or more cloud components in one or more networks.

In the depicted embodiment, the computer system600includes a processor608, memory620, storage610, interface606, and bus604. Although a particular computer system is depicted having a particular number of particular components in a particular arrangement, this disclosure contemplates any suitable computer system having any suitable number of any suitable components in any suitable arrangement.

Processor608may be a microprocessor, controller, or any other suitable computing device, resource, or combination of hardware, software and/or encoded logic operable to execute, either alone or in conjunction with other components, (e.g., memory620), the application622. Such functionality may include providing various features discussed herein. In particular embodiments, processor608may include hardware for executing instructions, such as those making up the application622. As an example, and not by way of limitation, to execute instructions, processor608may retrieve (or fetch) instructions from an internal register, an internal cache, memory620, or storage610; decode and execute them; and then write one or more results to an internal register, an internal cache, memory620, or storage610.

In particular embodiments, processor608may include one or more internal caches for data, instructions, or addresses. This disclosure contemplates processor608including any suitable number of any suitable internal caches, where appropriate. As an example, and not by way of limitation, processor608may include one or more instruction caches, one or more data caches, and one or more translation lookaside buffers (TLBs). Instructions in the instruction caches may be copies of instructions in memory620or storage610and the instruction caches may speed up retrieval of those instructions by processor608. Data in the data caches may be copies of data in memory620or storage610for instructions executing at processor608to operate on; the results of previous instructions executed at processor608for access by subsequent instructions executing at processor608, or for writing to memory620, or storage610; or other suitable data. The data caches may speed up read or write operations by processor608. The TLBs may speed up virtual-address translations for processor608. In particular embodiments, processor608may include one or more internal registers for data, instructions, or addresses. Depending on the embodiment, processor608may include any suitable number of any suitable internal registers, where appropriate. Where appropriate, processor608may include one or more arithmetic logic units (ALUs); be a multi-core processor; include one or more processors608; or any other suitable processor.

Memory620may be any form of volatile or non-volatile memory including, without limitation, magnetic media, optical media, random access memory (RAM), read-only memory (ROM), flash memory, removable media, or any other suitable local or remote memory component or components. In particular embodiments, memory620may include random access memory (RAM). This RAM may be volatile memory, where appropriate. Where appropriate, this RAM may be dynamic RAM (DRAM) or static RAM (SRAM). Moreover, where appropriate, this RAM may be single-ported or multi-ported RAM, or any other suitable type of RAM or memory. Memory620may include one or more memories620, where appropriate. Memory620may store any suitable data or information utilized by the computer system600, including software embedded in a computer readable medium, and/or encoded logic incorporated in hardware or otherwise stored (e.g., firmware). In particular embodiments, memory620may include main memory for storing instructions for processor608to execute or data for processor608to operate on. In particular embodiments, one or more memory management units (MMUs) may reside between processor608and memory620and facilitate accesses to memory620requested by processor608.

As an example, and not by way of limitation, the computer system600may load instructions from storage610or another source (such as, for example, another computer system) to memory620. Processor608may then load the instructions from memory620to an internal register or internal cache. To execute the instructions, processor608may retrieve the instructions from the internal register or internal cache and decode them. During or after execution of the instructions, processor608may write one or more results (which may be intermediate or final results) to the internal register or internal cache. Processor608may then write one or more of those results to memory620. In particular embodiments, processor608may execute only instructions in one or more internal registers or internal caches or in memory620(as opposed to storage610or elsewhere) and may operate only on data in one or more internal registers or internal caches or in memory620(as opposed to storage610or elsewhere).

In particular embodiments, storage610may include mass storage for data or instructions. As an example, and not by way of limitation, storage610may include a hard disk drive (HDD), a floppy disk drive, flash memory, an optical disc, a magneto-optical disc, magnetic tape, or a Universal Serial Bus (USB) drive or a combination of two or more of these. Storage610may include removable or non-removable (or fixed) media, where appropriate. Storage610may be internal or external to the computer system600, where appropriate. In particular embodiments, storage610may be non-volatile, solid-state memory. In particular embodiments, storage610may include read-only memory (ROM). Where appropriate, this ROM may be mask-programmed ROM, programmable ROM (PROM), erasable PROM (EPROM), electrically erasable PROM (EEPROM), electrically alterable ROM (EAROM), or flash memory or a combination of two or more of these. Storage610may take any suitable physical form and may comprise any suitable number or type of storage. Storage610may include one or more storage control units facilitating communication between processor608and storage610, where appropriate.

In particular embodiments, interface606may include hardware, encoded software, or both providing one or more interfaces for communication (such as, for example, packet-based communication) among any networks, any network devices, and/or any other computer systems. As an example, and not by way of limitation, communication interface606may include a network interface controller (NIC) or network adapter for communicating with an Ethernet or other wire-based network and/or a wireless NIC (WNIC) or wireless adapter for communicating with a wireless network.

Depending on the embodiment, interface606may be any type of interface suitable for any type of network for which computer system600is used. As an example, and not by way of limitation, computer system600can include (or communicate with) an ad-hoc network, a personal area network (PAN), a local area network (LAN), a wide area network (WAN), a metropolitan area network (MAN), or one or more portions of the Internet or a combination of two or more of these. One or more portions of one or more of these networks may be wired or wireless. As an example, computer system600can include (or communicate with) a wireless PAN (WPAN) (such as, for example, a BLUETOOTH WPAN), a WI-FI network, a WI-MAX network, an LTE network, an LTE-A network, a cellular telephone network (such as, for example, a Global System for Mobile Communications (GSM) network), or any other suitable wireless network or a combination of two or more of these. The computer system600may include any suitable interface606for any one or more of these networks, where appropriate.

In some embodiments, interface606may include one or more interfaces for one or more I/O devices. One or more of these I/O devices may enable communication between a person and the computer system600. As an example, and not by way of limitation, an I/O device may include a keyboard, keypad, microphone, monitor, mouse, printer, scanner, speaker, still camera, stylus, tablet, touchscreen, trackball, video camera, another suitable I/O device or a combination of two or more of these. An I/O device may include one or more sensors. Particular embodiments may include any suitable type and/or number of I/O devices and any suitable type and/or number of interfaces606for them. Where appropriate, interface606may include one or more drivers enabling processor608to drive one or more of these I/O devices. Interface606may include one or more interfaces606, where appropriate.

Bus604may include any combination of hardware, software embedded in a computer readable medium, and/or encoded logic incorporated in hardware or otherwise stored (e.g., firmware) to couple components of the computer system600to each other. As an example, and not by way of limitation, bus604may include an Accelerated Graphics Port (AGP) or other graphics bus, an Enhanced Industry Standard Architecture (EISA) bus, a front-side bus (FSB), a HYPERTRANSPORT (HT) interconnect, an Industry Standard Architecture (ISA) bus, an INFINIBAND interconnect, a low-pin-count (LPC) bus, a memory bus, a Micro Channel Architecture (MCA) bus, a Peripheral Component Interconnect (PCI) bus, a PCI-Express (PCI-X) bus, a serial advanced technology attachment (SATA) bus, a Video Electronics Standards Association local (VLB) bus, or any other suitable bus or a combination of two or more of these. Bus604may include any number, type, and/or configuration of buses604, where appropriate. In particular embodiments, one or more buses604(which may each include an address bus and a data bus) may couple processor608to memory620. Bus604may include one or more memory buses.

Herein, reference to a computer-readable storage medium encompasses one or more tangible computer-readable storage media possessing structures. As an example, and not by way of limitation, a computer-readable storage medium may include a semiconductor-based or other integrated circuit (IC) (such, as for example, a field-programmable gate array (FPGA) or an application-specific IC (ASIC)), a hard disk, an HDD, a hybrid hard drive (HHD), an optical disc, an optical disc drive (ODD), a magneto-optical disc, a magneto-optical drive, a floppy disk, a floppy disk drive (FDD), magnetic tape, a holographic storage medium, a solid-state drive (SSD), a RAM-drive, a SECURE DIGITAL card, a SECURE DIGITAL drive, a flash memory card, a flash memory drive, or any other suitable tangible computer-readable storage medium or a combination of two or more of these, where appropriate.

Particular embodiments may include one or more computer-readable storage media implementing any suitable storage. In particular embodiments, a computer-readable storage medium implements one or more portions of processor608(such as, for example, one or more internal registers or caches), one or more portions of memory620, one or more portions of storage610, or a combination of these, where appropriate. In particular embodiments, a computer-readable storage medium implements RAM or ROM. In particular embodiments, a computer-readable storage medium implements volatile or persistent memory In particular embodiments, one or more computer-readable storage media embody encoded software.

Herein, reference to encoded software may encompass one or more applications, bytecode, one or more computer programs, one or more executables, one or more instructions, logic, machine code, one or more scripts, or source code, and vice versa, where appropriate, that have been stored or encoded in a computer-readable storage medium. In particular embodiments, encoded software includes one or more application programming interfaces (APIs) stored or encoded in a computer-readable storage medium. Particular embodiments may use any suitable encoded software written or otherwise expressed in any suitable programming language or combination of programming languages stored or encoded in any suitable type or number of computer-readable storage media. In particular embodiments, encoded software may be expressed as source code or object code. In particular embodiments, encoded software is expressed in a higher-level programming language, such as, for example, C, Perl, or a suitable extension thereof. In particular embodiments, encoded software is expressed in a lower-level programming language, such as assembly language (or machine code). In particular embodiments, encoded software is expressed in JAVA. In particular embodiments, encoded software is expressed in Hyper Text Markup Language (HTML), Extensible Markup Language (XML), or other suitable markup language.

Depending on the embodiment, certain acts, events, or functions of any of the algorithms described herein can be performed in a different sequence, can be added, merged, or left out altogether (e.g., not all described acts or events are necessary for the practice of the algorithms). Moreover, in certain embodiments, acts or events can be performed concurrently, e.g., through multi-threaded processing, interrupt processing, or multiple processors or processor cores or on other parallel architectures, rather than sequentially Although certain computer-implemented tasks are described as being performed by a particular entity, other embodiments, are possible in which these tasks are performed by a different entity.