Agentic framework on an edge device

Abstract

An agentic framework is provided on a device that interacts with a cloud and runs apps and artificial intelligence (AI) models. An app and app metadata are downloaded from the cloud to the device. The app metadata describes requirements of the app for AI models to be used by the app. A search is performed in a database on the device that stores the app metadata and model metadata of edge models that are installed on the device to identify a target model among the edge models that satisfies the requirements. The target model is downloaded from a collection of downloadable models in the cloud in response to a determination that the target model is not already installed on the device.

Description

AGENTIC FRAMEWORK ON AN EDGE DEVICETECHNICAL FIELD

[0001] Embodiments of the invention relate to an edge device framework that supports artificial intelligence (AI) agents and interactions between edge devices and cloud services.BACKGROUND OF THE INVENTION

[0002] Agentic artificial intelligence (AI) systems are designed to operate with autonomy, with the ability to make decisions based on predefined goals and learned experiences. AI agents can utilize a variety of AI models for communicating and collaborating with humans and other AI systems to accomplish tasks. By utilizing diverse AI models, an agentic AI system can perceive its environment, make informed decisions, interact naturally with humans, and perform complex tasks autonomously. Agentic AI systems have the capabilities to function effectively across various domains and applications.

[0003] The AI models utilized in an agentic AI system may include machine learning models, deep learning models, natural language processing models, to name a few. Many of these models require a large memory footprint and computation resources. For example, Large Language Models (LLMs) models like GPT-3, GPT-4, and BERT, which are designed for understanding and generating natural language (i.e., human language) , enable agentic AI to interact with humans and process textual data. However, an LLM in a server cloud may contain billions of parameters, making it infeasible for an edge device to store a variety of large AI models for diverse purposes. Thus, it is a challenge to provide an agentic AI system on edge devices.SUMMARY OF THE INVENTION

[0004] In one embodiment, a method is provided for a device to provide an agentic framework. The method includes the step of downloading an app and app metadata from the cloud to the device. The app metadata describes requirements of the app for AI models to be used by the app. A search is performed in a database on the device that stores the app metadata and model metadata of edge models installed on the device to identify a target model among the edge models that satisfies the requirements. In response to a determination that the target model is not already installed on the device, the device downloads the target model from a collection of downloadable models in the cloud.

[0005] In another embodiment, a method is performed by a device to utilize a database on the device for improving inference performance of edge models. The device runs an agentic manager app. The agentic manager app sends a query to the database, and receives contextual information of the query from the database. The agentic manager then sends a prompt incorporating the contextual information to the target model; and receives a response from the target model. The response indicates action requests and identifying an app for the agentic manager app to invoke the app.

[0006] In yet another embodiment, a method is performed by a device to provide an assistant for helping a user to achieve a specific purpose. The assistant launches an agentic manager app on the device in response to a user request. A similarity search is performed based on the user request using an on-device database that stores data of the assistant to output a context for the user request. The data describes prompts for functionalities needed to achieve a task. The agentic manager app sends the prompts to a target model, the prompts incorporating the context. Then the agentic manager app receives a response from the target model, the response identifying one or more on-device apps and an action sequence for the agentic manager app to drive the one or more of the on-device apps.

[0007] In yet another embodiment, a system includes a cloud of servers and storage, the cloud including a model garden storing certified models downloadable to a device, an app store storing apps downloadable to the device, and cloud models and services. The system further includes a device in communication with the cloud, the device including processors and memory. The memory stores instructions executable by the processors to provide a device agentic framework, the device agentic framework including an agentic manager app, edge models and a database. The device is operative to perform any of the above methods.

[0008] Other aspects and features will become apparent to those ordinarily skilled in the art upon review of the following description of specific embodiments in conjunction with the accompanying figures.BRIEF DESCRIPTION OF DRAWINGS

[0009] The present invention is illustrated by way of example, and not by way of limitation, in the figures of the accompanying drawings in which like references indicate similar elements. It should be noted that different references to "an" or "one" embodiment in this disclosure are not necessarily to the same embodiment, and such references mean at least one. Further, when a particular feature, structure, or characteristic is described in connection with an embodiment, it is submitted that it is within the knowledge of one skilled in the art to effect such feature, structure, or characteristic in connection with other embodiments whether or not explicitly described.

[0010] FIG. 1 is a block diagram illustrating a device agentic framework architecture according to an embodiment.

[0011] FIG. 2 is a diagram illustrating the use of metadata for identifying a target model for an app according to one embodiment.

[0012] FIG. 3 is a diagram illustrating an agentic manager and its interactions with model service and apps according to one embodiment.

[0013] FIG. 4 is a diagram illustrating on-device assistants according to one embodiment.

[0014] FIG. 5A is a diagram illustrating the use of feature classifications to identify a target model for a prompt according to one embodiment.

[0015] FIG. 5B is a diagram illustrating the use of resource requirements to identify a target model for a prompt according to another embodiment.

[0016] FIG. 6 is a diagram illustrating embedding of app data according to one embodiment.

[0017] FIG. 7 is a diagram illustrating token size optimization according to one embodiment.

[0018] FIG. 8 is a block diagram illustrating a device in communication with a cloud according to one embodiment.

[0019] FIG. 9 is a flow diagram illustrating a method for a device to provide an agentic framework according to one embodiment.

[0020] FIG. 10 is a flow diagram illustrating a method for utilizing a database to improve inference performance of edge models according to one embodiment.

[0021] FIG. 11 is a flow diagram illustrating a method performed by a device providing an assistant for helping a user to achieve a specific purpose according to one embodiment.DETAILED DESCRIPTION OF THE INVENTION

[0022] In the following description, numerous specific details are set forth. However, it is understood that embodiments of the invention may be practiced without these specific details. In other instances, well-known circuits, structures, and techniques have not been shown in detail in order not to obscure the  understanding of this description. It will be appreciated, however, by one skilled in the art, that the invention may be practiced without such specific details. Those of ordinary skill in the art, with the included descriptions, will be able to implement appropriate functionality without undue experimentation. As used herein, the term “and / or” includes any and all combinations of one or more of the associated listed items.

[0023] In the following description, the term “agentic manager” refers to a software application or service that can make autonomous decisions based on available and inferred information, and drive other applications (the “agentic app” ) , or devices, or systems. The term “agentic app” (abbreviated as “app” ) refers to a software application that can be commanded and / or orchestrated by an agentic manager and take actions to provide services accessible to users, other apps, software, and / or systems. The term “cloud” refers to a remote system of server computers, storage, and software, providing services to an edge device over a network, such as the Internet. The term “edge device” (abbreviated as “device” ) refers to a device that is local to the service that it provides. For example, a smartphone is an edge device because it is local to the user. Non-limiting examples of edge devices include smartphones, wearable devices, laptops, Internet-of-things (IOTs) , navigation devices, infotainment devices, robotic devices, etc. The term “AI model” (abbreviated as “model” ) as used herein includes and is not limited to: machine learning models, deep learning models, customized learning models, natural language processing models, large language models (LLM) , and the like, as well as neural networks and variations thereof. The term “cloud AI model” or “cloud model” refers to an AI model in the cloud, and “edge AI model” or “edge model” refers to an AI model installed on an edge device.

[0024] The disclosure herein describes a device agentic framework that enables edge devices to execute agentic apps and orchestrate the actions of these apps with an agentic manager. The agentic manager and / or the agentic apps may use edge AI models, or cloud AI models on demand, to perform AI operations. The agentic apps and agentic manager working together are “agentic” in that they can make autonomous decisions to achieve a given goal, for example, a goal given by a user or by another app or by another device. The autonomous decisions may be based on learned data, metadata, pre-configured data, a combination of these data, etc.

[0025] FIG. 1 is a block diagram illustrating a device agentic framework architecture according to an embodiment. In this embodiment, an edge device (e.g., device 100) interacts with cloud providers of one or more companies, collectively referred to as a cloud 120. The cloud 120 provides a wide range of cloud services; some cloud providers may provide AI services such as downloadable AI models and some cloud providers may provide remotely accessible AI models. In one embodiment, the cloud 120 provides a cloud app store 121, a model garden 123, and cloud models and services 125, which interact with the device 100 through cloud interfaces 122, 124, and 126, respectively. The cloud app store 121 provides downloadable apps, the model garden 123 provides downloadable models, and the cloud models and services 125 provides cloud models for a device to use remotely.

[0026] The device 100 supports a device agentic framework 105, which includes software code executed by the device 100 to manage agentic apps ( “apps 150” ) , edge models 164, and the interactions with the cloud 120 and users. The device agentic framework 105 includes an app and model manager 130, which further includes a store manager 131 and a garden manager 133. The store manager 131 may download apps 150 to the device 100 from the cloud app store 121. The garden manager 133 may download AI models from the model garden 123 according to the metadata of a downloaded app. The garden manager 133 may also download an AI model from the model garden 123 according to the metadata of an installed app on the device 100 which is not downloaded from the cloud 120. Through a model service 160, the app and model manager 130 also interact with the edge models 164 and a local database 167 (also referred to as an on- device database) . The local database 167 includes databases 163 and an embedding database used for Retrieval Augmented Generation (RAG) , hereinafter referred to as a RAG database 162 (also referred to as an embedding database) . The data in the RAG database 162 contain information including but not limited to: information embeddings about the apps installed on the device 100, features of the edge models, available system functions 110, etc. Embeddings are usually, but not limited to, high-dimensional vectors encoding semantic contexts and relationships of information (such as phrases or tokens) . Databases with embeddings make it easy and accurate to search for semantically similar information. The edge models 164 herein include and are not limited to: machine learning models, deep learning models, customized learning models, natural language processing models, large language models (LLM) , and the like, as well as neural networks and variations thereof. For example, the edge models 164 may include base models, low-rank adaptation (LoRa) models, ControlNet models, and other additional models. The model service 160 further includes a permission manager 165 and a log manager 166, which will be described in detail later. The model service 160 interacts with the cloud 120 through a cloud proxy 161.

[0027] The device agentic framework 105 further includes an agentic manager 180 (also referred to as an “agentic manager app” ) , which includes an action engine 181, a prompt engine 182, and user interfaces 183, the operations of all of which are coordinated by logic cores 185. The agentic manager 180 interacts with the apps 150 and the model service 160, and has access to system functions 110. The agentic manager accesses one or more models through model service 160 to execute AI inferences. In one embodiment, the agentic manager is tasked with managing and coordinating the operations of the apps 150.

[0028] The device agentic framework 105 provides an agentic experience on an edge device to orchestrate apps in an intuitive way. App developers define app metadata to describe the behaviors and properties of the app 150, and upload the app metadata with the app 150 to the cloud app store 121. The app metadata may be stored in one or more files. A non-limiting example of the file format is JSON. The app metadata may include a feature summary, descriptions of the features, and interface specification of the app 150. The interface specification describes what action requests the app can accept. The app metadata may further specify a specific model to use, or specify a criterion for a model so that the model service 160 can choose a model for the app according to the criterion. In some embodiments, the app metadata may also describe one or more prompt rules or hints that can be used by the agentic manager 180 to drive the app 150, e.g., prompt rules used by the agentic manager 180 to compose prompts to a model such that the model can generate a response describing a sequence of action requests for the agentic manager 180 to invoke a given functionality of the app 150. The model used by the agentic manager 180 for this purpose (generating response that is used for driving the agentic apps 150) is the “primary model” . The primary model is usually an edge model but is not limited to an edge model.

[0029] The store manager 131 on the device 100 downloads the app 150 with the app metadata. The store manager 131 installs the app 150 on the device 100, and sends the app metadata to the model service 160 for storage and search operations. The model service 160 may convert the app metadata into embeddings (which may be a semantic representation of the app metadata) and store the embeddings in the RAG database 162 to facilitate fast searching.

[0030] The model garden 123 maintains model metadata for every certified and downloadable model in the cloud 120. The models in the model garden 123 are certified to run on the device 100. The certification may be provided by the manufacturer or vendor of the device 100, by the manufacturer or vendor of the processors on the device 100 that run the AI models, or other entities holding rights to part or whole of the system stack of the device 100, e.g., the operating system, or device driver. The model metadata describes features of the model, including but not limited to: task type and description, vendor,  benchmarks scores, supported input and output data size and type, and power, performance, memory footprint on different hardware platforms. A token is a basic data unit of the internal representation of the processed data in a model. Data input to the model is converted to token in the model, and the result is converted from token to output data. The supported data type described in the model metadata may include one or more of the following: text (of different languages, etc. ) , code (of different programming languages, etc. ) , image (e.g., emoji, cartoon, plants, etc. ) , voice (e.g., male, female, etc. ) , video (e.g., movie, cartoon, documentary, etc. ) , and other data types. In short, the model metadata describes what the model can accept as well as other information, such as whether the model can receive text or image, whether the text length can be 1000 words or 10k words, etc.

[0031] The model garden 123 maintains the model metadata in a database in the cloud 120. Similarly, the model service 160 maintains the model metadata of every model it manages (including model 164 and / or model 126) in local databases (e.g., databases 163 and / or RAG database 162) on the device 100. In one embodiment, the model metadata may be stored in the RAG database 162 for embedding search (also referred to as “similarity search” ) and similarity ranking. Similarity ranking refers to the ranking of the search results according to their similarity to a search criterion, e.g., search for a target model to be used by an app 150. Any target model (e.g., base models and / or LoRa models; edge models or cloud models) meeting the criteria can be used by the app 150. The model service 160 may automatically bind a target model with the app 150 according to the app’s model criteria. The model service 160 can also determine for an app 150 whether to switch between an edge model 164 and a cloud model, between two edge models 164, or between two cloud models.

[0032] FIG. 2 is a diagram illustrating the use of metadata for identifying a target model for an app 200 according to one embodiment. Referring to FIG. 1 and FIG. 2, the app 200 in FIG. 2 may be any of the apps 150 and the agentic manager 180 (which is also an app) . As mentioned above, the local database 167 (database 163 and / or RAG database 162) stores metadata 250, including app metadata associated with each app 200 and the model metadata associated with each edge model 164. To identify the target model of the app 200, the model service 160 performs a search in the local database 167 to match the requirements indicated in the app metadata with the features of the model metadata. If one of the edge models 164 is a match to the app 200, the model service 160 binds the matched edge model to the app 200 (step 201) . Otherwise, the model service contacts the cloud models and services 125 (step 202) to find one of the cloud models 224 that satisfies the app’s requirements, and binds that cloud model to the app 200 (step 203) .

[0033] During runtime of the app 200 that uses the model service 160, the model service 160 can switch to use an edge model 164 or a cloud model 224, and automatically bind the model to the app 200 without disrupting the user experience. The model switching may be based on, for example, the requirements of the app 200 (as indicated in the app metadata or the app’s prompts) , the capability and constraints of the edge models 164 (as indicated in the model metadata) , the user’s requests or privacy constraints, etc.

[0034] During runtime, the model service 160 may detect a model switching condition, such as model usage exceeding a threshold, device resource consumption exceeding a limit, prompts containing private data, etc., the model service 160 may automatically switch the target model of an app 200 from an edge model 164 to a cloud model 224 or vice versa. The model service 160 may automatically switch the target model of an app 200 from an edge model 164 to another edge model. In one embodiment, if the model service 160 switches an edge model 164 to a cloud model 224 for an app 200, the cloud proxy 161 in the model service 160 can redirect the app’s call to the edge model 164 to the cloud model 224.

[0035] The cloud models 224 can be only available in the cloud 120 to the apps 150 because of a number of reasons. Non-limiting examples include the following: the model is not ported to the specific device where the app is currently running; the model owner does not allow the model to be used on a device; the model is too large to fit into the device memory; or the app specifies to use a cloud model.

[0036] Referring to FIG. 1, the cloud 120 includes the cloud app store 121 and the accompanied model garden 123. If an app 150 requires certain models (e.g., base models and / or LoRa models) to run, the app 150 does not need to bundle the models in its download package. The download package includes the app metadata describing the features of the app 150 and the requirements on the models that the app 150 uses. When the app 150 is downloaded by the store manager 131 on the device 100, the store manager 131 reads the app metadata to determine if the needed models are already available on the device 100. If not, the garden manager 133 automatically downloads the models from the model garden 123 in the cloud 120.

[0037] One advantage of the disclosed framework is that apps and models are decoupled, e.g., models can be downloaded to the device 100 on demand. The agentic manager 180 can trigger the store manager 131 to automatically download an app and the associated app metadata from the model garden 123 when the app is needed for a given functionality. The models used by the app 150 can be downloaded from the cloud 120 as needed.

[0038] FIG. 3 is a diagram illustrating the agentic manager 180 and its interactions with the model service 160 and the apps 150 according to one embodiment. Although the edge models 164 are used as an example in FIG. 3, it is understood that cloud models may be used instead of the edge models 154 for one or more of the apps 150.

[0039] In a first step, the agentic manager 180 interacts with the RAG database 162 in the model service 160. The agentic manager 180 sends a query to the RAG database 162, where the query may be in the form of a phrase. The RAG database 162 responds with a result that has semantic similarity to the query phrase. The result typically contains local or personal information that is used by the agentic manager 180 as part of the rules and / or context (collectively referred to as “contextual information” ) in its prompt to its target AI model. This target AI model is referred to as a primary model. The primary model is typically an edge model 164, but is not required to be an edge model 164. The rules and context incorporated into the prompt can improve the quality and the precision of the response, and, thereby, enhance the user experience. In a second step, the agentic manager 180 (more specifically, the prompt engine 182) sends a prompt to the primary model where the prompt includes “rules and / or context and a question. ” The primary model generates an inference output as a response to the prompt. The response may indicate one or more target apps (e.g., one or more apps 150) and actions that the agentic manager 180 can request the target apps to execute. In a third step, the agentic manager 180 (more specifically, the action engine 181) sends an action request to a target app; the target app executes the action and returns a feedback to the agentic manager 180. When the action engine 181 issues an action request to an app, the prompt engine 182 may send a new prompt to the primary model. The issuance of an action request and the new prompt can be concurrent.

[0040] The communication between the agentic manager 180 and the apps 150 is bi-directional. The agentic manager 180 can request the apps 150 to take actions, and the apps 150 can send feedback to the agentic manager 180. For example, the action may be to order a burger, and the feedback may be a list of burgers offered by the food ordering apps on the device 100 or accessible to the device 100. The list may be provided to the agentic manager 180 as feedback, and the agentic manager 180 may supplement the list with relevant information (e.g., nutrition and / or price) before generating an output to the user. In some scenarios, the feedback from the apps 150 to the agentic manager 180 may be an indication of “success” or “failure” with respect to the food order. Non-limiting examples for the communication between the apps 150 and the  agentic manager 180 include: shared memory, broadcast, interface language such as AIDL (Android Interface Definition Language) , JSON, Android Intent, etc.

[0041] In carrying out the action request, the app 150 may use an AI model that it binds to. This AI model may or may not be the primary model. Similar to the first step and the second step mentioned before, the app 150 may send a request to the RAG database 162 and receives rules and / or context, and then send a prompt (including the rules / context) to its target AI model and receives an inference output as a response to the prompt.

[0042] As an example, when a user makes a request to the agentic manager 180, e.g., placing a food order with dietary restrictions, the agentic manager 180 may identify an on-device food ordering app (e.g., one of the apps 150) based on the RAG search result and the response to a prompt to the primary model, and the action engine 181 can call the identified food ordering app into action. The food ordering app may call an AI model to find a dish that complies with the user’s dietary restrictions. In one embodiment, when the device 100 has not installed any suitable food ordering apps, the agentic manager 180 may trigger the store manager 131 to automatically download an app on demand, such as a food ordering app in this example. The downloaded app can be a mobile app, an instant app, a mini-program, a card, a widget, etc., each of which is a term of art understood by software developers.

[0043] In some scenarios, one or more of the apps 150 may not use AI models. For example, the agentic manager 180 uses a primary model to understand how to drive the food ordering app (e.g., how to interact with the app) , whereas the food ordering app does not use an AI model. Some other apps 150 may use AI models. For example, an image editing app may use an AI model to generate an image from text. The agentic manager 180 may issue an action request (e.g., “create an image of a robot” ) to the image editing app, which app then accesses its AI model to generate an image. This AI model can be different from the primary model used by the agentic manager 180.

[0044] Referring to FIG. 1, the agentic manager 180 provides various forms of user interfaces 183 to interact with users. For example, the user may invoke the agentic manager 180 by touch, voice, keyboard commands, inputs to a graphical user interface (GUI) , and / or other means. The user interfaces 183 may have text-to-speech and speech-to-text functions to convert user speech input into text, and text output to speech. The user interfaces 183 may include touch sensors to sense users’ touch, cameras to detect users’ gestures, etc. The agentic manager 180 may utilize one or more edge models 164 for speech recognition and generation. In one embodiment, the agentic manager 180 may be invoked by a trigger phrase from the user, such as “Hi there” .

[0045] Referring to FIG. 1, the log manager 166 of the model service 160 provides logging and accounting services for the edge models 164. The log manager 166 may keep track of the usage statistics of each edge model 164. One or more of the apps 150 may be given a quota for accessing a given edge model 164. The accounting information maintained by the log manager 166 may be used to grant quota-based access for the app 150 to access the given edge model 164. In one scenario, a user may be charged a fee by an app 150 for using an edge model 164 through the app 150. In another scenario, an app 150 may be charged a fee for using an edge model 164. The fee may be collected by the app developer, the model developer, and / or the device vendor, etc. If the app 150 runs out of its quota for one specific edge model, the model service 160 can switch out that edge model to an alternative model that the app 150 has an unused quota or has unlimited access. The model switching may be performed automatically based on a predetermined configuration or runtime determination of similar models. Additionally or alternatively, the user may provide input to the choice of the alternative model. The alternative model may be a cloud model 224 (FIG. 2) for remote access by the app 150. The alternative model may have lower accuracy and / or  longer latency than the original model. The usage statistics include but are not limited to one or more of the following: token size (e.g., the number of input / output tokens processed by the model) , execution time (e.g., model usage time) , memory usage footprint, etc. In some embodiments, the logging and accounting services for the cloud models 224 may be performed by the cloud models and services 125 and / or the model service 160, and the usage statistics of the cloud models 224 is accessible to the model service 160.

[0046] The permission manager 165 of the model service 160 authenticates and authorizes the apps 150 to access the edge models 164. One or more of the base models and their associated models (e.g., LoRa models, ControlNet, etc. ) on the device 100 may be accessible only to specific apps. For example, a third party who develops a model may authorize those apps from a given company to use that model. The permission manager 165 may check a certification of the app 150 to determine the identity of the app 150, and then determine whether the app 150 is authorized to use that model. The device 100 and / or an edge model 164 can be configured to require the authorization process to be automatic or manual. The automatic authorization may go through an authentication process on the app 150. The manual authorization process may ask the user to approve the request from the app 150 to use an edge model 164. According to the model metadata, the authorization process may be specific to an edge model 164, or to a group of edge models 164 meeting a given criterion (e.g., from the same vendor or another shared characteristic) . For example, the developer of a group of models may provide a certification for an app to use all of the models in the group.

[0047] The device 100 has access to a variety of system functionalities and services (collectively referred to as the system functions 110) such as time, location, device maker information, device ID information such as phone number, device settings such as font size, device control functions such as flight mode, etc., that are not incorporated into the edge models 164. A description of the system functions 110 may be stored in the on-device databases 163 and the RAG database 162. The agentic manager 180 can incorporate the system functions 110 into commands when invoking the apps 150 and / or the edge models 164. For example, a request from a user may be “order a burger from the nearest Café that is currently open. ” The agentic manager 180 can send the request to the model service 160, which searches the RAG database 162 to determine the context of the request and identifies the system functions 110 needed to fulfill the request, such as the location and time service. The agentic manager 180 then calls the location and time service for the user’s location and the current time, and incorporates the location and time information into a prompt to a model to perform inference. Based on the inference output, the agentic manager 180 triggers one or more apps 150 to perform actions. In one embodiment, a system function plugin 115 is incorporated into the agentic manager 180 for calling system functions 110. Non-limiting examples of the plugin implementation include the following: shell code, an interpreter, or an Android application or service, etc.

[0048] FIG. 4 is a diagram illustrating on-device assistants ( “little assistants 400” ) provided by the device agentic framework 105 (FIG. 1) according to one embodiment. A little assistant 400 is an AI assistant that can operate the apps 150, the system functions 110, etc., and can trigger the operations of the agentic manager 180 and / or another little assistant 400. Different little assistants 400 perform different tasks for different purposes. Each little assistant 400 can help a user to achieve a specific purpose. For example, one little assistant 400 may be a dating assistant, which can tell the user the nearby suitable venues that are

[0049] currently open for a meetup. Another little assistant 400 can identify a fast-food restaurant that currently offers the cheapest hamburger special. Suppose that there are three fast-food restaurants of interest to the user, each providing its own online app where its daily special is posted. The little assistant 400 can search the daily special in each app, incorporate the system functions of time and location, and output the cheapest hamburger item for the user to review before placing an order. In one embodiment, the little assistants 400 can be provided to the user as a link or an icon on the home screen of the device 100 for quick  access by the user. Alternatively, the little assistants 400 can be part of the agentic manager 180 or the apps 150 installed on the device 100. The little assistant 400 may be invoked by the user by touch (e.g., tapping or clicking) , voice, or other types of commands. Additionally or alternatively, the little assistant 400 may be invoked by an app 150 or by another little assistant 400 on the device 100. When invoked, the little assistant 400 may launch the agentic manager 180 to generate image, text, or speech via user interfaces for user interactions. Alternatively, the little assistant 400 may run in the background to provide background service.

[0050] The little assistant 400 may be described in multiple files of multiple file formats, e.g., . doc files, JSON files, etc. The contents of these files may be converted into embeddings and stored as little assistant data 450 in the RAG database 162 to allow search and context generation. The agentic manager 180 may incorporate the context into prompts to an AI model (e.g., the primary model of the agentic manager 180) . The agentic manager 180 may incorporate the response of the primary model into action requests to one or more apps 150, which may use AI models (e.g., the edge models 164 and / or the cloud models

[0051] 224) , if any, to produce actions.

[0052] The little assistant data 450 may include a description of prompts that can be sent by the agentic manager 180 to the primary model such that the primary model can generate high-quality responses for the agentic manager 180 to interact with target apps to invoke the functionalities needed for achieving a task, where the functionalities can be provided by the apps 150, by the system functions 110, or by the cloud 120. The descriptions may also include an interface description, a description of the little assistant’s features for its intended purpose, e.g., a dating assistant that uses Starbucks reservation, a meal takeout assistant that uses McDonald app and KFC app, etc. The descriptions may also include the local

[0053] knowledge of the little assistant 400 in the form of a document or document embeddings. The local knowledge may include supplemental information related to its intended purpose and may be of interest to the user, e.g., a dating assistant may describe the ambience, affordability, and / or crowdedness of the venue, a meal takeout assistant may describe the nutritional value of each food item on the menu. The interface description with respect to the interaction with the agentic manager 180 may include an action sequence that the agentic manager 180 follows to send action requests to one or more apps 150.

[0054] As mentioned previously, the model service 160 enables an app 150 to switch between an edge model and a cloud model on demand. The model service 160 can also enable the prompt engine 182 of the agentic manager 180 to dispatch a prompt to either an edge model or a cloud model transparent to the user based on one or more criteria. The agentic manager 180 may interleave the use of edge models and cloud models to complete a task without being noticed by the user. FIG. 5A is a diagram illustrating the use of feature classifications to identify a target model for a prompt according to one embodiment. The prompt may be issued by the agentic manager 180 or any of the apps 150. In this embodiment, the criteria for determining the target model (i.e., an edge model 164 or a cloud model 224) of a prompt is based on the features contained in the prompt. The RAG database 162 includes two sections, a local section 510 for local features and a non-local section 520 for non-local features. The local section 510 contains features that can be served by the edge model 164 or installed apps 150 while the non-local section 520 contains features that cannot or should not be served by the edge model 164 or installed apps 150. For example, some edge model / installed apps may generate illegal or unethical responses to prompts with certain features in the non-local section 520. In a RAG similarity search, if the search output returns a feature list that includes only local features, the target model is an edge model 164. If all of the local features in the feature list rank higher than all of the non-local features in the feature list, the target model is also an edge model 164. On the other hand, if all of the non-local features in the feature list rank higher than all of the local features in the feature  list, the target model is a cloud model 224. In another embodiment, a different selecting algorithm can be used for target model selection. For example, if one of the local features ranks first in the RAG similarity search, the target model is an edge model 164. On the other hand, if one of the non-local features ranks first, the target model is a cloud model 224.

[0055] Further explanations and examples of using the feature classification are as follows. When the agentic manager 180 has a prompt (aquestion) , and decides where (edge model 164 or cloud model 224) to send this prompt, it needs to know which model can answer the question capably, safely, and responsively. Here “capability” means that the model’s answer to the question needs to be reasonable and correct. “Safety” means the prompt not to leak user privacy or secrets. “Responsiveness” means the model not to take too long to output a response to the prompt.

[0056] Regarding “capability” , some considerations are provided as follows. Every application may have some knowledge of a specific domain. For example, a solar app (e.g., one of the apps 150) may have knowledge related to the Sun, the Earth, etc. When the agentic manager 180 has a prompt related to the Solar system, it can dispatch the prompt to an edge model. The edge model can respond with some actions targeted to the solar app. Then the agentic manager 180 can issue an action request to the solar app. Thus, when the agentic manager 180 knows that a prompt can be fulfilled by installed apps 150, the agentic manager 180 dispatches the prompt to an edge model 164.

[0057] Other example prompts are: “Order a KFC meal. ” “I am hungry, what do you recommend? ” When a KFC app is installed on the device, the agentic manager 180 can dispatch the prompt to an edge model, which will come up with some actions targeted to the KFC app. To support the prompt dispatching, the RAG database 162 can store keywords “KFC” , “Starbucks” in the local section 510 if both KFC app and Starbucks app are installed on the device. The RAG similarity search for “order a meal for me” may return a list of semantically similar results ranked by their similarity scores, e.g., 1. KFC (in the local section 510) , 2. Starbuck (in the local section 510) , 3. Panda (in the non-local section 520) . The agentic manager 180 then knows it should dispatch the prompt to an edge model 164, which is to respond with an action for the agentic manager 180 to send to the KFC app.

[0058] Some questions may not be strongly related to installed apps. For example, the question “can we eat giant pandas? ” can be answered directly by a model, or can be answered better by cloud services such as apps in the cloud. The question “how to survive outside the Galaxy? ” can be answered by an encyclopedia cloud service driven by a cloud model. An edge model may be able to answer the question but may not give a reasonable one. For the question “can we eat giant pandas? ” , a 72B version of an LLM may answer the following: “Giant pandas are protected animal species. It is illegal to eat them. ” A 4B version of the LLM may answer “Giant panda is delicious. ” Here, 72B and 4B are indications of the size of the LLM. To identify a target model for such questions, a threshold may be set for the RAG similarity scores. Thus, the RAG similarity search for the giant panda question / prompt would return a low similarity score in a RAG database that has the keywords “KFC” and “Starbucks” in the local section 510.

[0059] In the embodiment of FIG. 5A, phrases and keywords may be stored in the non-local section 520 of the RAG database 162, so that the agentic manager 180 can be informed that the prompts related to those phrases and keywords are supported only by the cloud models 224. In the above example, the non-local section 520 of the RAG vector database 162 may store the keyword “panda” . Then the RAG similarity search for “can we eat giant pandas? ” may return a list of semantically similar results in the order of similarity, e.g., 1. Panda (in the non-local section 520) , 2. Animal (in the non-local section 520) , 3. KFC (in the local section 520) , etc. According to the search result, the agentic manager 180 then dispatches the prompt to a cloud model 224 as the non-local features rank higher than the local feature.

[0060] FIG. 5B is a diagram illustrating the use of resource requirements to identify a target model for a prompt according to another embodiment. In this embodiment, the criteria for determining the target model of a prompt include the potential resource and / or latency requirements. This requirement check may be implemented as a runtime check by a requirement checker 550 on the device 100. If the requirement checker 550 estimates that a prompt is to consume a large amount (e.g., above a threshold) of resources such as memory footprint or execution time, the prompt can be sent to a cloud model 224. Furthermore, the requirement checker 550 may determine whether the prompt includes private data that cannot be sent to a cloud model 224. If the prompt includes private data (e.g., a personal photo, identity information) , the prompt may only be sent to an edge model 164.

[0061] FIG. 6 is a diagram illustrating the embedding generation procedure of app data according to one embodiment. Referring to FIG. 1 and FIG. 6, the app 150 stores its data (e.g., app metadata and any additional data needed for running the app) on the device 100 in the form of embeddings. In one embodiment, the model service 160 includes an edge embedding generator 620 to generate embeddings for the app data and to store the embeddings in the RAG database 162. The model service 160 may use the embeddings to aid the edge models 164 to optimize the inference output. Generation of the embeddings can consume a significant amount of computing resources on the device 100. In one embodiment, the cloud app store 121 includes a cloud embedding generator 610 to generate embeddings for the app data when an app is uploaded to the cloud app store 121. The device 100 can download the embeddings whenever needed without consuming the device resources for embedding generation. In some scenarios where an app 150 is installed on the device (instead of downloading from the cloud app store 121) , the embeddings can be generated on the device 100, e.g., by the model service 160.

[0062] FIG. 7 is a diagram illustrating token size optimization according to one embodiment. The inference performance of an AI model can be optimized by reducing the token size. With limited on-device computing and storage resources, optimization of inference performance of an edge model 164 can significantly improve user experience. Although the following description is directed to edge models, it is understood that the same optimization can be applied to cloud models.

[0063] A prompt received by the edge model 164 is first tokenized into tokens, with each token having a fixed number of bytes. In some embodiments, the tokens are then converted to embeddings by the edge model 164. In one embodiment, the agentic manager 180 includes a mapping list 710 that maps prompt phrases to identifiers and vice versa. An identifier uniquely identifies a phrase in a prompt. A phrase can include a number of words in a natural language such as English, Spanish, Chinese, French, etc. An identifier can be a number, an alphanumeric representation, or another data format. A model that processes natural language such as an LLM maps natural language words into tokens. By reducing the word count or character count in a prompt, the token size is also reduced.

[0064] Thus, instead of sending a textual prompt, an embodiment of the prompt engine 182 can replace some or all of the original phrases in the textual prompt with identifiers. In one scenario, the prompt engine 182 uses the mapping list 710 to convert some or all of the prompt phrases to identifiers and sends only the identifiers (in place of original phrases) as input to the edge model 164. The output of the edge model 164 contains only identifiers, and the prompt engine 182 uses the mapping list 710 to convert the identifiers in the output into phrases. Alternatively, the prompt engine 182 can insert identifiers corresponding to the prompt phrases before or after the phrases, and request the edge model 164 to output only identifiers. In this alternative embodiment, the input contains both identifiers and the original phrases, while the output contains only identifiers. The request to the edge model 164 may include instructions, hints,  and / or contexts to guide the model’s response. Replacing phrases with identifiers can improve the inference performance of AI models.

[0065] FIG. 8 is a block diagram illustrating a device 800 in communication with a cloud 801 according to one embodiment. The device 800 and the cloud 801 may be an example of the device 100 and the cloud 120, respectively, in FIG. 1.

[0066] The device 800 includes processing hardware 810, which further includes processors 813 and AI hardware 812. Non-limiting examples of the processors 813 include a central processing unit (CPU) , a graphic processing unit (GPU) , a digital signal processor, a media processor, etc. The device 800 further includes a memory 820 such as a static random-access memory (SRAM) device, a dynamic random-access memory (DRAM) device, a flash memory device, and / or other volatile or non-volatile memory devices. The memory 820 may store the device agentic framework 105 (FIG. 1) .

[0067] The device 800 may further include a network interface 830, which may be a wired interface and / or a wireless interface. It is understood that the device 800 is simplified for illustration purposes; additional hardware and software components are not shown.

[0068] The cloud 801 includes servers 802 and storage 803 to support the operations of the cloud app store 121, the model garden 123, and the cloud models and services 125 in FIG. 1. The cloud 801 and the device 800 are in bi-directional communication via a network, such as the Internet or other types of networks.

[0069] FIG. 9 is a flow diagram illustrating a method 900 for a device to provide an agentic framework according to one embodiment. The method 900 may be performed by the device 100 (FIG. 1) , the device 800 (FIG. 8) , or another computing system. In one embodiment, the method 900 starts with step 910 when the device downloads an app and app metadata from a cloud. The app metadata describes requirements of the app for AI models to be used by the app. At step 920, a search is performed in a database on the device that stores the app metadata and model metadata of edge models that are installed on the device to identify a target model among the edge models that satisfies the requirements. At step 930, the target model is downloaded from a collection of downloadable models in the cloud in response to a determination that the target model is not already installed on the device.

[0070] In one embodiment, an agentic manager app on the device receives a prompt rule described in the app metadata, composes a prompt to a primary model bound to the agentic manager app, and receives a response from the primary model. The response includes a sequence of action requests to invoke a given functionality of the app. In one embodiment, the model metadata associated with each edge model describes one or more of following items: task type and description, vendor, benchmarks scores, supported input and output token size and type, and power, performance, memory footprint on different hardware platforms. In one embodiment, when a model switching condition is detected at runtime of the app, a model switching operation is performed to switch the target model from an edge model to a cloud model in the cloud for use by the app remotely. The cloud model satisfies the requirements of the app described in the app metadata. In one embodiment, the device maintains usage statistics of each edge model on the device. The app is granted access to an edge model based on the usage statistics and a quota given to the app for accessing the edge model. A user may be charged a fee for using the app on the device based on the usage statistics of the edge model. When it is detected that the quota is exceeded, a model switching operation is performed to switch from the edge model to another AI model for the app to use. In one embodiment, the usage statistics measures one or more of: token size used by the edge model, execution time of the edge model, and memory footprint of executing the edge model. In one embodiment, the device further performs an authorization process when the app accesses the target model. The authorization process may be specific to the target model or a group of models meeting a given criterion. In one embodiment, when downloading the app and  the app metadata from the cloud, the device downloads the app with embeddings from the cloud when the embeddings are available for download, wherein the embeddings are generated by the cloud from at least the app metadata. The embeddings may be generated on the device when the embeddings are not available for download. The device stores the embeddings in the database on the device. The search is performed using the embeddings in the database to identify the target model. In one embodiment, the

[0071] database is a vector database. In one embodiment, the phrases of a natural language in a prompt are mapped to corresponding identifiers using a predetermined mapping list to reduce input and / or output token size of the target model. The prompt including the corresponding identifiers is sent to the target model. An output is received from the target model, the output containing only identifiers in the predetermined mapping list.

[0072] FIG. 10 is a flow diagram illustrating a method 1000 for a device to utilize a database to improve inference performance of edge models according to one embodiment. The method 1000 may be performed by the device 100 (FIG. 1) , the device 800 (FIG. 8) , or another computing system. In one embodiment, the method 1000 starts with step 1010 when an agentic manager app on the device sends a query to the database. At step 1120 the agentic manager receives contextual information of the query from the database. At step 1130, the agentic manager sends a prompt incorporating the contextual information to a target model. At step 1140, the agentic manager receives a response from the target model, the response indicating action requests and identifying an app for the agentic manager app to invoke the app.

[0073] In one embodiment, when the agentic manager app receives the response, the agentic manager app automatically triggers a download of the app and app metadata from a cloud to the device when the app is not on the device. In one embodiment, the agentic manager app stores in the database information about system functions that are available to the device, and incorporates the system functions into prompts to edge models on the device. The system functions include at least one of a location function, a time function, a function for device maker information, a function for device ID information, a function for device control, or a function for settings. In one embodiment, the database is used to classify a list of features in the prompt as a combination of local features and non-location features. The on-device apps can serve local features and cannot serve non-local features. The prompt is directed to the target model, which is identified based on classification of the features. An edge model is identified as the target model when the list of features include the local features only, when all of the local features in the list are ranked higher than the non-local features in the list, or when one of the local features is ranked first in the list. A cloud model is identified as the target model when the list of features include the non-local features only, when all of the non-local features in the list are ranked higher than the local features in the list, or when one of the non-local features is ranked first in the list. In one embodiment, the device estimates the consumption of device resources by the target model serving the prompt. In response to a determination that the consumption exceeds a threshold, the prompt is sent to a cloud model. When the prompt contains private data, the prompt is sent to an edge model. In one embodiment, the database is an embedding database.

[0074] FIG. 11 is a flow diagram illustrating a method 1100 for a device to provide an assistant for helping a user to achieve a specific purpose according to one embodiment. The method 1100 may be performed by the device 100 (FIG. 1) , the device 800 (FIG. 8) , or another computing system. In one embodiment, the method 1100 starts with step 1110 when the assistant launches an agentic manager app on the device in response to a user request. At step 1120, a similarity search is performed based on the user request using an on-device database that stores data of the assistant to output a context for the user request. The data describes prompts for functionalities needed to achieve a task. At step 1130, the agentic manager app sends the prompts to a target model, the prompts incorporating the context. At step 1140, the agentic  manager app receives a response from the target model, the response identifying one or more on-device apps and an action sequence for the agentic manager app to drive the one or more of the on-device apps. In one embodiment, the functionalities are provided by the one or more on-device apps, system functions, or a cloud system to achieve the specific purpose.

[0075] The operations of the flow diagrams of FIG. 9 -FIG. 11 have been described with reference to the exemplary embodiments of FIG. 1 and FIG. 8. However, it should be understood that the operations of the flow diagrams of FIG. 9 -FIG. 11 can be performed by embodiments of the invention other than the embodiments of FIG. 1 and FIG. 8, and the embodiments of FIG. 9 -FIG. 11 can perform operations different than those discussed with reference to the flow diagrams. It is understood that the order of operations shown in the flow diagrams of FIG. 9 -FIG. 11 is a non-limiting example. Alternative embodiments may perform the operations in a different order, combine certain operations, overlap certain operations, etc.

[0076] Various functional components or blocks have been described herein. As will be appreciated by persons skilled in the art, the functional blocks will preferably be implemented through circuits (either dedicated circuits or general-purpose circuits, which operate under the control of one or more processors and coded instructions) , which will typically comprise transistors that are configured in such a way as to control the operation of the circuitry in accordance with the functions and operations described herein.

[0077] While the invention has been described in terms of several embodiments, those skilled in the art will recognize that the invention is not limited to the embodiments described, and can be practiced with modification and alteration within the spirit and scope of the appended claims. The description is thus to be regarded as illustrative instead of limiting.

Claims

1.A method of a device providing an agentic framework, comprising:downloading an app and app metadata from a cloud to the device, wherein the app metadata describes requirements of the app for artificial intelligence (AI) models to be used by the app;performing a search in a database on the device that stores the app metadata and model metadata of edge models installed on the device to identify a target model among the edge models that satisfies the requirements; anddownloading the target model from a collection of downloadable models in the cloud in response to a determination that the target model is not already installed on the device.2.The method of claim 1, further comprising:receiving, by an agentic manager app on the device, a prompt rule described in the app metadata;composing a prompt to a primary model bound to the agentic manager app;receiving a response from the primary model, the response including a sequence of action requests to invoke a given functionality of the app.3.The method of claim 1, wherein the model metadata associated with each edge model describes one or more of following items: task type and description, vendor, benchmarks scores, supported input and output token size and type, and power, performance, memory footprint on different hardware platforms.4.The method of claim 1, further comprising:detecting a model switching condition at runtime of the app; andswitching the target model from an edge model to a cloud model in the cloud for use by the app remotely, wherein the cloud model satisfies the requirements of the app described in the app metadata.5.The method of claim 1, further comprising:maintaining usage statistics of each of a plurality of edge models on the device; andgranting the app access to an edge model based on the usage statistics and a quota given to the app for accessing the edge model.6.The method of claim 5, further comprising:charging a user a fee for using the app on the device based on the usage statistics of the edge model.7.The method of claim 5, further comprising:detecting that the quota is exceeded; andswitching from the edge model to another AI model for the app to use.8.The method of claim 5, wherein the usage statistics measures one or more of: token size used by the edge model, execution time of the edge model, and memory footprint of executing the edge model.9.The method of claim 1, further comprising:performing an authorization process when the app accesses the target model, wherein the authorization process is specific to the target model or a group of models meeting a given criterion.10.The method of claim 1, wherein downloading the app and the app metadata from the cloud further comprises:downloading the app with embeddings from the cloud when the embeddings are available for download, wherein the embeddings are generated by the cloud from at least the app metadata;generating the embeddings on the device when the embeddings are not available for download;storing the embeddings in the database on the device; andperforming the search using the embeddings in the database.11.The method of claim 1, wherein the database is a vector database.12.The method of claim 1, further comprising:mapping phrases of a natural language in a prompt to corresponding identifiers using a predetermined mapping list to reduce input and / or output token size of the target model;sending the prompt including the corresponding identifiers to the target model; andreceiving an output from the target model, the output containing only identifiers in the predetermined mapping list.13.A method performed by a device to utilize a database on the device for improving inference performance of edge models, comprising:sending a query from an agentic manager app to the database;receiving contextual information of the query from the database;sending a prompt incorporating the contextual information from the agentic manager app to a target model; andreceiving a response from the target model, the response indicating action requests and identifying an app for the agentic manager app to invoke the app.14.The method of claim 13, wherein receiving the response further comprisesautomatically triggering, by the agentic manager app, a download of the app and app metadata from a cloud to the device when the app is not on the device.15.The method of claim 13, further comprising:storing, in the database, information about system functions that are available to the device; andincorporating the system functions into prompts to edge models on the device.16.The method of claim 15, wherein the system functions include at least one of a location function, a time function, a function for device maker information, a function for device ID information, a function for device control, or a function for settings.17.The method of claim 13, further comprising:using the database to classify a list of features in the prompt as a combination of local features and non-location features, wherein on-device apps can serve local features and cannot serve non-local features; anddirecting the prompt to the target model, which is identified based on classification of the features.18.The method of claim 17, further comprising:identifying an edge model as the target model when the list of features include the local features only, when all of the local features in the list are ranked higher than the non-local features in the list, or when one of the local features is ranked first in the list.19.The method of claim 17, further comprising:identifying a cloud model as the target model when the list of features include the non-local features only, when all of the non-local features in the list are ranked higher than the local features in the list, or when one of the non-local features is ranked first in the list.20.The method of claim 13, further comprising:estimating consumption of device resources by the target model serving the prompt; andin response to a determination that the consumption exceeds a threshold, sending the prompt to a cloud model.21.The method of claim 13, further comprising:sending the prompt to an edge model when the prompt contains private data.22.The method of claim 13, wherein the database is an embedding database.23.The method performed by a device to provide an assistant for helping a user to achieve a specific purpose, comprising:launching an agentic manager app on the device in response to a user request;performing a similarity search based on the user request using an on-device database that stores data of the assistant to output a context for the user request, wherein the data describes prompts for functionalities needed to achieve a task;sending the prompts from the agentic manager app to a target model, the prompts incorporating the context; andreceiving a response from the target model, the response identifying one or more on-device apps and an action sequence for the agentic manager app to drive the one or more of the on-device apps.24.The method of claim 23, wherein the functionalities are provided by the one or more on-device apps, system functions, or a cloud system to achieve the specific purpose.25.A system comprising:a cloud of servers and storage, the cloud including a model garden storing certified models downloadable to a device, an app store storing a plurality of apps downloadable to the device, and cloud models and services; andthe device in communication with the cloud, the device including processors and memory, the memory storing instructions executable by the processors to provide a device agentic framework, the device agentic framework including an agentic manager app, edge models and a database, wherein the device is operative to perform the methods of claims 1-12.26.A system comprising:a cloud of servers and storage, the cloud including a model garden storing certified models downloadable to a device, an app store storing a plurality of apps downloadable to the device, and cloud models and services; andthe device in communication with the cloud, the device including processors and memory, the memory storing instructions executable by the processors to provide a device agentic framework, the device agentic framework including an agentic manager app, edge models and a database, wherein the device is operative to perform the methods of claims 13-22.27.A system comprising:a cloud of servers and storage, the cloud including a model garden storing certified models downloadable to a device, an app store storing a plurality of apps downloadable to the device, and cloud models and services; andthe device in communication with the cloud, the device including processors and memory, the memory storing instructions executable by the processors to provide a device agentic framework, the device agentic framework including an agentic manager app, edge models and a database, wherein the device is operative to perform the methods of claims 23 and 24.

Images