WO2025244643A1

WO2025244643A1 - Generative model control for performing tasks using multiple generative models

Info

Publication number: WO2025244643A1
Application number: PCT/US2024/030803
Authority: WO
Inventors: Victor Carbune; Matthew Sharifi
Original assignee: Google LLC
Current assignee: Google LLC
Priority date: 2024-05-23
Filing date: 2024-05-23
Publication date: 2025-11-27
Anticipated expiration: 2026-11-23

Abstract

Methods, systems, and apparatus, including computer programs encoded on a computer storage medium, for controlling the participation of generative models in a multi-agent system. One of the methods includes receiving an input for a task to be processed by a group of generative models to generate a final output for the task; and processing the input by the group of the generative models across a plurality of steps, including: for each intermediate step, obtaining context data at the intermediate step; generating based on the context data, control data for a target generative model in the group; providing the context data and the control data to the target generative model in the group; obtaining an output from the target generative model generated in response to the context data and the control data; and updating the context data for the task based on the output from the target generative model.

Description

GENERATIVE MODEL CONTROL FOR PERFORMING TASKS USING MULTIPLE

GENERATIVE MODELS

BACKGROUND

[1] This specification relates to processing a request using a group of generative models.

[2] Generative models have demonstrated state of the art performance across a wide range of tasks, such as text generation (e.g., writing, summarization, translation, coding), image generation, and audio generation. Generative models use very large neural network models that are trained on vast amounts of data. For example, a large language model (LLM) can include a transformer-based neural network model with self-attention capabilities and can achieve general-purpose language understanding and generation in response to a query. Thus, generative models are being deployed in various applications, e.g., as a coding assistant, as an email writing assistant, and for generating images in a presentation.

[3] A generative agent is a software program that uses a generative model to generate a generative output in response to an input, such as a prompt in natural language that requests the generative agent to perform a specific task.

SUMMARY

[4] This specification describes systems and techniques for using a control generative model to manage and control the participation of two or more generative models in a multiagent system.

[5] In a multi-agent system, a group of generative models processes an input for a task to generate an output for the task. In other words, two or more generative models in the multiagent system interact with one another to solve a task.

[6] In some cases, a user may invoke multiple generative models to generate an output for a task.

[7] In some cases, a user may invoke a first generative model to generate an output for a task and the first generative model may invoke one or more other generative models to collaboratively generate the output for the task.

[8] Generally, the group of generative models process the input for the task across a plurality of steps. At each step, a respective generative model in the group can generate a generative output.

[9] However, when multiple generative models interact with each other, e.g., through conversations, to generate an output for a task, there is a risk that the multiple generative models may fail to successfully complete the task within an amount of computational resources that has been allotted for the task or may complete the task while consuming an excessive amount of computational resources. For example, this can occur because one or more generative models may generate an excessive amount of outputs, generate an output that is irrelevant to the task, or generate too much detail on a topic without making progress towards solving the task. Unlike human-human interactions, generative models may generate outputs that are not helpful to completing the task, but may incur significant computational cost and end up being counterproductive. For example, the outputs may be irrelevant, or the models may be configured by bad actors to prevent other models from completing tasks.

[10] Some chatroom systems provide a basic control by removing a particular generative language model from the conversation, e.g.. banning or blocking the particular generative language model, in certain circumstances. However, these approaches unnecessarily limit the particular generative language model’s contribution to the conversation entirely without taking into account that the particular generative language model may provide a useful output in later stages of the conversation if properly prompted.

[11] This specification describes systems and techniques for using a control generative model to manage and control the outputs generated from a group of multiple generative models for a task.

[12] In some implementations, the control generative model can generate control data that defines a compute budget for a target generative model that defines an amount of computational resources that the target generative model consumes in a step.

[13] In some implementations, the control generative model can generate semantic control data that causes the target generative model to generate an output that focuses on an aspect of the task.

[14] In some implementations, the control generative model can monitor the multiple generative models’ collective progress of solving the task, and can determine which generative model from the multiple generative models should generate an output at the next step.

[15] In general, one innovative aspect of the subject matter described in this specification can be embodied in methods that include the actions of receiving an input for a task to be processed by a group of generative models to generate a final output for the task; and processing the input by the group of the generative models across a plurality of steps, wherein a respective generative model in the group generates a generative output at each step of the plurality of steps, and processing the input includes, for each intermediate step of the plurality of steps, obtaining, by a control generative model, context data for the task at the intermediate step; generating, by the control generative model and based on the context data for the task at the intermediate step, control data for a target generative model in the group; providing, by the control generative model, the context data for the task at the intermediate step and the control data to the target generative model in the group; obtaining, by the control generative model, an output from the target generative model generated in response to the context data and the control data; and updating, by the control generative model, the context data for the task based on the output from the target generative model. 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. For a system of one or more computers to be configured to perform particular operations or actions means that the system has installed on it software, firmware, hardware, or a combination of them that in operation cause the system to perform the operations or actions. For one or more computer programs to be configured to perform particular operations or actions means that the one or more programs include instructions that, when executed by data processing apparatus, cause the apparatus to perform the operations or actions.

[16] The foregoing and other embodiments can each optionally include one or more of the following features, alone or in combination. In particular, one embodiment includes all the following features in combination. The control data includes a compute budget for the target generative model, and the compute budget defines an amount of computational resources that the target generative model consumes in the intermediate step. The control data defines a number of tokens in the output from the target generative model generated at the intermediate step. The control data limits the number of tokens in the output from the target generative model generated at the intermediate step, and wherein limiting the number of tokens in the output from the target generative model generated at the intermediate step does not reduce a final progress score for the task, the final progress score being a measure of an extent to which the task has been completed after the input has been processed across the plurality of steps to generate the final output for the task. The control data includes semantic control data that causes the target generative model to generate an output that focuses on an aspect of the task. The control data causes the target generative model to generate the output at the intermediate step that indicates no change to the context data. The actions include for each intermediate step, selecting, by the control generative model and based on the context data for the task at the intermediate step, the target generative model from the group of the generative models. The context data includes respective previous output generated by one or more generative models in the group at one or more previous steps before the intermediate step. The context data includes a progress score indicating a level of progress towards completion of the task. The context data includes a level of importance of the task. The context data includes an amount of compute budget left at the intermediate step for completing the task by the group of the generative models. The context data includes metadata about the group of the generative models. The actions include receiving the final output for the task generated by the group of the generative models at a final step of the plurality of steps; generating training data for training the control generative model based on the context data for the task at each of the plurality of steps; and training the control generative model using the training data. The actions include determining, by the control generative model, that the task is completed after receiving the final output from a generative model at the final step.

[17] Particular embodiments of the subject matter described in this specification can be implemented so as to realize one or more of the following advantages.

[18] The systems and methods described in this specification can reduce the computational resources, e.g., memory and processor cycles, consumed by multiple generative models for generating a final output for a task without reducing the overall progress for completing the task. Rather than allowing one or more generative models to generate an excessive amount of outputs, generate an output that is irrelevant to the task, or generate too much detail on a topic without making progress to ards solving the task, the control generative model can reduce the computation cost by monitoring the multiple generative models' collective progress of solving the task, determining which target generative model from the multiple generative models should generate an output in the next step, and limiting the number of tokens in the output from the target generative model.

[19] The systems and methods can improve the efficiency of providing a final output for a task by the multiple generative models. For example, under a given amount of tokens for one or more of the multiple generative models, the control generative model can generate the final output in fewer steps because the control generative model can guide the conversation of the multiple generative models using semantic control data that causes the generative models to generate an output that focuses on an aspect of the task. In some implementations, the systems and methods can reduce the overhead on a user interacting with the multiple generative models because the conversations visible to the user are less verbose.

[20] The details of one or more embodiments of the subject matter of this specification are set forth in the accompanying drawings and the description below. Other features, aspects. and advantages of the subject matter will become apparent from the description, the drawings, and the claims.

BRIEF DESCRIPTION OF THE DRAWINGS

[21] FIG. 1 is a diagram of an example multi-agent system.

[22] FIG. 2 is an example user interface displaying a conversation generated by multiple generative models controlled by a control generative model.

[23] FIG. 3 A is a flow chart of an example process for controlling the participation of two or more generative models.

[24] FIG. 3B is a flow chart of an example process performed at each intermediate step of a plurality of steps for controlling the participation of two or more generative models.

[25] FIG. 4 is a flow chart of an example process for training a control generative model.

[26] Like reference numbers and designations in the various drawings indicate like elements.

DETAILED DESCRIPTION

[27] FIG. 1 is a diagram of an example multi-agent system 100.

[28] The system 100 is an example of a system implemented as computer programs on one or more computers 116 in one or more locations, in which the systems, components, and techniques described in this specification are implemented. The one or more computers 116 can include personal computers, mobile communication devices, servers, and other devices that can send and receive data over a network. The network (not show n), such as a local area network (“LAN’'), wide area network (“WAN”), the Internet, or a combination thereof, connects the one or more computers 116 that implements the system. The system can use a single computer or multiple computers operating in conjunction with one another, including, for example, a set of remote computers deployed as a cloud computing sendee.

[29] The system 100 receives an input 102 for a task and generates an output 114 for the task. In order to perform the task, the system processes the input using a group of generative models 110. The group of generative models 110 processes the input 102 across a plurality of steps.

[30] At each step, a respective generative model in the group generates a generative output.

[31] For example, at each step, a generative model receives an input, and generates an output. The input can include one or more of: the original input for the task, an output generated at a previous step, an output generated at more than one previous step, or prompts that are independent of the input.

[32] The multi-agent system 100 includes multiple generative models that collaboratively solve a task.

[33] For example, in the example of FIG. 1, the system 100 includes a first generative model 110(1) and a second generative model 110(2), collectively referred to as generative models 110. In other examples, the multi-agent system 100 can have three, four, five or more generative models 110.

[34] The multiple generative models 110 can be models of different sizes, different neural network architectures, different capabilities, or different specializations.

[35] For example, the multiple generative models can include one neural network model with fewer parameters and another neural network model with (relatively) more parameters.

[36] The multiple generative models can include a first neural network model trained to perform a broad range of tasks, and a second neural netw ork model trained on training data in a task domain to perform a specific task in the task domain.

[37] The multiple generative models can use natural language as a common interface to communicate with each other.

[38] The multiple generative models can include one or more models deployed on a local device and one or more other models deployed in the cloud. In some implementations, the multiple generative models can include a relatively smaller general neural network deployed on a user device, and one or more other relatively larger or specialized neural networks deployed on a server. In some implementations, all the generative models in the multi-agent system 100 can be implemented in the cloud. In some implementations, one or more generative models can have access to private user data, while other generative models may not have access to private user data.

[39] In some implementations, a user device of a user can invoke multiple generative models to solve a task if the user believes that these generative models can jointly solve the task better than a single generative model. In some implementations, a user device of a user can invoke a generative model and the generative model can invoke one or more other generative models in order to delegate some aspects of the task for better productivity.

[40] For example, a user may query' two different generative models in order to get a more balanced perspective on a certain topic. As another example, a user may query generative models that have different capabilities. For example, a user may query one generative model that can book hotels and another generative model that can book flights. [41] A generative model is a machine learning (ML) model that generates content, including text, images, audio, or other synthetic data, based on an input. During inference, the generative model 110 can generate a generative output, e.g., a content of a certain type, in response to a query input. In some implementations, the generative model 110 can generate multi-modal outputs, such as an image and a corresponding text describing the image.

[42] In some implementations, the generative model 110 can be configured to process an input sequence of tokens to generate an output sequence of tokens. The tokens can represent any appropriate type of content, e.g., text, image, video, audio, or some combination of the above. For example, the generative model can be a large language model (LLM) and can be configured to process an input sequence of tokens from a vocabulary of text tokens to generate an output sequence of tokens from the vocabulary.

[43] More generally, the generative model 110 can be any appropriate neural network that receives an input sequence that includes text tokens and auto-regressively generates an output sequence that includes text tokens. For example, the generative model 110 can be a Transformer-based language model neural network or a recurrent neural network-based language model neural network.

[44] In some situations, the generative model 110 can be referred to as an auto-regressive neural network when the neural network used to implement the language model auto- regressively generates an output sequence of tokens. More specifically, the auto-regressively generated output is created by generating each particular token in the output sequence conditioned on a current input sequence that includes any tokens that precede the particular token in the output sequence, i.e., the tokens that have already been generated for any previous positions in the output sequence that precede the particular position of the particular token, and a context input that provides context for the output sequence.

[45] For example, the current input sequence when generating a token at any given position in the output sequence can include the input sequence and the tokens at any preceding positions that precede the given position in the output sequence. As a particular example, the current input sequence can include the input sequence followed by the tokens at any preceding positions that precede the given position in the output sequence. Optionally, the input and the current output sequence can be separated by one or more predetermined tokens within the current input sequence.

[46] More specifically, to generate a particular token at a particular position within an output sequence, the generative model 110 can process the current input sequence to generate a score distribution (e.g., a probability distribution) that assigns a respective score, e.g., a respective probability, to each token in a vocabulary' of tokens. The language model neural network can then select, as the particular token, a token from the vocabulary using the score distribution. For example, the neural network of the language model can greedily select the highest-scoring token or can sample, e.g., using nucleus sampling or another sampling technique, a token from the distribution.

[47] As a particular example, the generative model 110 can be an auto-regressive Transformer-based neural network that includes (i) a plurality of attention blocks that each apply a self-attention operation and (ii) an output subnetwork that processes an output of the last attention block to generate the score distribution.

[48] The generative model 110 can have any of a variety of Transformer-based neural network architectures. Examples of such architectures include those described in J. Hoffmann, S. Borgeaud, A. Mensch, E. Buchatskaya, T. Cai, E. Rutherford, D. d. L. Casas, L. A. Hendricks, J. Welbl, A. Clark, et al. Training compute-optimal large language models, arXiv preprint arXiv:2203.15556, 2022; J.W. Rae, S. Borgeaud, T. Cai. K. Millican, J. Hoffmann, H. F. Song. J. Aslanides. S. Henderson, R. Ring, S. Young, E. Rutherford, T. Hennigan, J. Menick, A. Cassirer. R. Powell, G. van den Driessche, L. A. Hendricks. M. Rauh, P. Huang, A. Glaese, J. Welbl, S. Dathathri, S. Huang, J. Uesato, J. Mellor, I. Higgins, A. Creswell, N. McAleese, A.Wu, E. Eisen, S. M. Jayakumar, E. Buchatskaya, D. Budden, E. Sutherland, K. Simonyan, M. Paganini, L. Sifre, L. Martens, X. L. Li, A. Kuncoro, A. Nematzadeh. E. Gribovskaya, D. Donato, A. Lazaridou, A. Mensch, J. Lespiau, M. Tsimpoukelli, N. Grigorev, D. Fritz, T. Sottiaux, M. Pajarskas, T. Pohlen, Z. Gong, D.

Toyama, C. de Masson d’Autume, Y. Li, T. Terzi, V. Mikulik, I. Babuschkin, A. Clark, D. de Las Casas, A. Guy, C. Jones, J. Bradbury', M. Johnson, B. A. Hechtman, L. Weidingen I. Gabriel, W. S. Isaac. E. Lockhart, S. Osindero, L. Rimell. C. Dyer, O. Vinyals. K. Ayoub, J. Stanway, L. Bennett, D. Hassabis, K. Kavukcuoglu, and G. Irving. Scaling language models: Methods, analysis & insights from training gopher. CoRR, abs/2112. 11446, 2021; Cohn Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li. and Peter J Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. arXiv preprint arXiv: 1910.10683, 2019; Daniel Adiwardana, Minh- Thang Luong, David R. So, Jamie Hall, Noah Fiedel, Romal Thoppilan, Zi Yang, Apoorv Kulshreshtha, Gaurav Nemade, Yifeng Lu, and Quoc V. Le. Towards a human-like opendomain chatbot. CoRR, abs/2001.09977, 2020; and Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam. Girish Sastry. Amanda Askell, et al. Language models are few-shot learners. arXiv preprint arXiv:2005. 14165, 2020.

[49] In some implementations, the generative model 110 can use a decoder-only architecture that includes many decoder blocks, and without using an encoder. Each decoder block can include a self-attention layer and a feed forward neural network. The transformerbased generative model is an example of a generative model that the systems and techniques herein can be applicable.

[50] More generally, the system and techniques described herein are applicable to other types of generative models. One example of the generative model 110 can be a diffusion model. As another example, the generative model 110 can be a diffusion model that uses a text-to-image diffusion model to generate a first image, and then applies one or more superresolution diffusion models to generate a final image. As another example, the generative model 110 can be an auto-regressive generative model that auto-regressively generates tokens representing audio, video, images, or other data. As yet another example, the generative model 110 can be a masked token generative model that sequentially unmasks tokens that represent text, video, audio, images, or other data during generation.

[51] The system 100 receives an input 102 for a task and processes the input 102 by a group of generative models 110 to generate a final output 114 for the task. The system 100 processes the input by the group of the generative models 110 across multiple steps. At each step, a respective generative model in the group generates a generative output.

[52] However, in some systems, one or more generative models may fail to successfully complete the task within a compute budget for the task or may complete the task while consuming an excessive amount of computational resources.

[53] A compute budget for a task can define a maximum amount of computational resources (e.g. memory and/or processor cycles) that can be used to perform the task. In some implementations, the system can use all of the compute budget to perform the task. For example, the computer budget can define the amount of computational resources (e.g. memory and/or processor cycles) that is used to perform the task. In some implementations, a compute budget can be assigned to a generative model.

[54] A compute budget for a generative model can define a maximum amount of computational resources (e.g. memory' and/or processor cycles) that the generative model consumes over a period of time (e.g. during an intermediate step). In some implementations, a generative model can use all of the compute budget over the period of time.Thus, the compute budget can define the amount of computational resources that a generative model consumes over the period of time. For example, the one or more generative models may generate an excessive amount of outputs, generate an output that is irrelevant to the task, or generate too much detail on a topic without making progress towards solving the task. Therefore, it is desirable to set compute budget(s) to control the generative outputs generated by the multiple generative models at the plurality⁷ of steps. In some cases, a compute budget can define a number (e.g. maximum number) of tokens to be used during one or more steps performed by the multiple generative models to complete a task.

[55] In some systems, two or more generative models in the group can be tasked to handle different aspects of the task. For example, one generative model can be a specialized model for booking hotels and another generative model can be a specialized model for booking flights. Therefore, it is desirable to coordinate the generative outputs generated by the multiple generative models at the plurality⁷ of steps.

[56] The system 100 uses a control generative model 106 to manage and control the outputs generated from multiple generative models for a task. The control generative model 106 can manage and control the output generated from one of the generative models at each step. In some implementations, the control generative model 106 can be a generative language model trained to manage and control conversations in a group chat environment. In some implementations, the control generative model 106 can be a large language model (LLM).

[57] The control generative model 106 and the multiple generative models 110 can be implemented locally with regard to one another. For example, the control generative model 106 and the multiple generative models 110 can all be implemented on the same user device or on the same set of one or more computers in a server system. In some implementations, the control generative model 106 and the multiple generative models 110 can be implemented remotely from one another. For example, the system can include the first generative model 110(1) running on a user device, the second generative model 110(2) running on a remote server in the cloud.

[58] The control generative model 106 can generate control data 108 that controls an output generated from a generative model. The system 100 can provide a prompt input to the control generative model 106, and the prompt input can request the control generative model to generate control data 108 that can be parsed by a generative model to generate a desired output.

[59] For example, the prompt input to the control generative model can be ’'which model should generate the next output given this context?” The control generative model 106 can process the prompt input and can generate control data indicating which model should generate the next output.

[60] As another example, the prompt input to the control generative model can be '‘the next generative model is going to be model A, and what should be the number of tokens in the output generated by model A?’’ The control generative model 106 can process the prompt input and can generate control data indicating the limit on the number of tokens in the output generated by model A.

[61] The system can provide the control data 108 as input to the generative model, e.g., as hyperparameters of the generative model or as a part of the prompt to the generative model or as a part of a prompt input that can be parsed by the generative model. For example, the target generative model that is going to generate output at the current step can be the first generative model 110(1) and the control generative model 106 can generate control data 108 that controls an output generated from the first generative model 110(1).

[62] In some implementations, the control data 108 can include one or more hyperparameters that define how outputs are generated using the target generative model. The control generative model 106 can generate the one or more hyperparameters based on the context data 104 for the task at the current step. For example, the one or more hyperparameters can set a maximum length of decoded tokens, or a beam size that is explored at each step when generating an output, can constrain a decoding algorithm through an additional function that provides step-by-step scores, or can skip a number of rounds of decoding for a target generative model.

[63] For example, the control generative model 106 can receive a prompt that asks the control generative model to generate control data 108 that includes a respective control beam score for each candidate in a beam of a beam search algorithm. A generative model 110 can have a model beam score for each candidate in the beam. The system can generate a modified model beam score by multiplying the control beam score with a weight and adding the weighted control beam score to the model beam score. Thus, the generative model 110 can use the modified model beam score to control the beam search based on the candidates in the beam, such as reorder the candidates based on the modified beam scores for the candidates.

In some implementations, the system can reorder the candidates in the beam at special tokens, e.g., when a sentence ends or when a subtask is completed.

[64] In some implementations, a generative model 110 can start solving a task or a subtask with multi-step reasoning. The control generative model 106 can determine that the multi- step reasoning is not useful, e.g.. through a prompt or score. The control generative model 106 can generate control data 108 that stops the entire remaining rounds of decoding.

[65] In some implementations, the control data 108 can include a compute budget for a target generative model. In some implementations, the compute budget can define an amount (or a maximum amount) of computational resources, e.g., memory⁷ and processor cycles, that the target generative model consumes (or can consume) in the intermediate step. In some implementations, the compute budget can define a total amount (or maximum total amount) of computational resources that the target generative model can consume over multiple steps. Thus, based on the total amount of computational resources that the target generative model can consume, the control generative model 106 can determine an amount of computational resources that the target generative model can consume for each step of the multiple steps.

[66] For example, the control generative model 106 can generate control data 108(1) for the first generative model 110(1) in the group based on the context data 104 for the task at step n. The control data 108(1) can include a compute budget for the first generative model 110(1) that defines an amount (or maximum amount) of computational resources that the first generative model 110(1) should consume in the current step n.

[67] In some implementations, the control data 108 can define a number of tokens in the output from a target generative model generated at the current step. For example, the control data 108(1) can define a number of tokens in the output from the first generative model 110(1). For example, the control data 108(1) can define the number of tokens per second in the output from the first generative model 1 10(1). Thus, the system 100 can provide a latency control limiting tokens per second, allowing sufficient time for interventions from the system or a user before a generative model consumes an amount of computational resource that is more than a threshold. For example, the control data 108 can include data that defines a number of rounds of processings performed during a decoding loop, and the generative model 110 can exit the decoding loop when the number of rounds of processings is performed. As another example, the control data 108 can include data that defines an amount of waiting time after several decoding steps to achieve a desired token rate.

[68] In some implementations, the control data 108 can limit the number of tokens in the output from the target generative model generated at the current step. For example, the control generative model 106 can determine an upper limit for the number of tokens in the output from the target generative model generated at the current step.

[69] In some implementations, the control generative model 106 can generate control data limiting or defining the number of tokens in the output from the target generative model generated at the current step so that the limits on the number of tokens does not reduce a final progress score for the task. The final progress score can be a measure of an extent to which the task has been completed after the input has been processed across the plurality of steps to generate the final output for the task. Thus, the computation saving does not slow down the progress towards providing the final output 114 for the task. In some cases, the computation saving can improve the efficiency and can speed up the progress towards providing the final output 114 for the task.

[70] For example, an agent may have generated lengthy outputs in the previous steps. The control generative model can limit the number of tokens in the output from the agent generated at the current step. In response, the agent can generate a more concise output at the current step, without slowing down the progress towards completing the task.

[71] In some implementations, the control data 108 can include semantic control data that causes the target generative model to generate an output that focuses on an aspect of the task. The semantic control data can dynamically adjust each generative model’s level of involvement in solving the task across the plurality of steps.

[72] For example, at step n+1, the control generative model can generate control data 108(2) for the second generative model 110(2) in the group based on the context data 104 for the task at the current step n+1. The control data 108(2) can include semantic control data that causes the second generative model 110(2) to generate the generative output 112(2) at step n+1 that focuses on an aspect of the task.

[73] The control generative model 106 can generate the control data 108 that controls an output generated from a generative model based on context data 104. For example, the control generative model 106 can generate control data 108 for a target generative model 110 in the group based on the context data 104 for the task at the current step.

[74] The context data 104 can include any information related to generating a response for the task. In some implementations, the context data 104 can include the previous output generated by the generative models at previous steps before the current step, e.g., the entire conversation history. For example, the context data at step n+1 can include context data at step n and the generative output 112 generated by the first generative model at step n.

[75] In some implementations, the context data 104 can include data that summarizes the previous output generated by one or more generative models in the group at one or more previous steps before the current step. For example, instead of maintaining the entire conversation history in the memory, the system 100 can ask the control generative model to generate a summary of the conversation history. [76] In some implementations, the context data 104 can include a level of importance of the task or an aspect of the task. For example, the context data can indicate the level of details required in the final output. Based on the context data indicating the level of details required in the final output, the control generative model 106 can generate control data that controls the amount of computation performed by a target generative model.

[77] In some implementations, the context data 104 can include an amount of compute budget left at the current step for completing the task by the group of the generative models. The compute budget left can be based on a total compute budget for the group of the generative models. The compute budget left can be based on an individual compute budget for each of one or more generative models in the group. For example, if the total compute budget for the group of the generative models is less than a threshold, the control generative model 106 can determine to spend the budget on a generative model that is most likely to produce some useful result for the task.

[78] In some implementations, the context data 104 can include metadata about one or more generative models in the group. For example, the context data 104 can include metadata indicating that the first generative model is specialized at hotel booking and the second generative model is specialized at flight booking.

[79] In some implementations, the context data 104 can include a user input, such as natural language feedback from a user, and the control generative model 106 can generate control data 108 based on the user input.

[80] For example, the user may provide natural language feedback stating, “I think Agent 1 can solve most of the problems related to language learning on its own.” The control generative model 106 can select Agent 1 as the target generative model for the next one or more steps, and can generate control data that causes Agent 1 to solve problems related to language learning.

[81] As another example, the user may provide natural language feedback stating, “I think Agent 4 should provide less advice when it comes to math problems.” The control generative model 106 can generate control data that limits the number of tokens in the output from the Agent 4 generated at the current step if the current step is related to solving a math problem.

[82] In some implementations, the context data 104 can include input provided by a user through a user interface (UI) of the system 100. For example, the system 100 can display sliders in the UI to allow the user to limit compute budget, e.g., the number of tokens in the output from a target generative model. In some cases, the system 100 can display text boxes in the UI to allow the user to limit the generative output from a target generative model on a topic, or to provide feedback directly in the conversation.

[83] In some implementations, the context data 104 can include a combination of the various types of context data discussed above and any other suitable context data, such as previous output generated by the generative models at previous one or more steps, data that summarizes the previous output, a level of importance of the task or an aspect of the task, an amount of compute budget left at the current step for completing the task, metadata about one or more generative models in the group, and input from a user device.

[84] In some implementations, the group of generative models can generate output across a plurality of steps in a predetermined order, such as turn by turn. Thus, the target generative model at the current step can be predetermined.

[85] In some other implementations, the group of generative models may not generate outputs in a predetermined order, and the control generative model 106 can select the target generative model from the group of the generative models based on the context data 104 for the task at the current step. For example, the control generative model 106 can select, from the group of generative models, the generative model that is likely to generate a productive output towards completing the task in the input 102.

[86] In some implementations, the control generative model can select a generative model for solving a task based on metadata for the generative model. For example, the context data 104 can include metadata indicating that the first generative model has been previously trained to solve problems related to subtask A and the second generative model has been previously trained to solve problems related to subtask B. Based on the context data 104, the control generative model 106 can determine that the multi-agent system 100 should solve subtask A at the current step. Thus, the control generative model 106 can select the first generative model for solving subtask A at the cunent step. As another example, the metadata for a generative model can indicate what tools (e.g., a calculator or a search engine) the generative model has access to. Based on a subtask to be solved, the control generative model can determine that a generative model with access to a particular tool may be sufficient or needed. For example, if a subtask involves math calculations, the control generative model can determine that a generative model with access to a calculator is sufficient. If a subtask involves searching information, the control generative model can determine that a generative model with access to a search engine is needed.

[87] For example, the context data 104 can include previous tasks and responses generated by a group of generative models and how each generative model contributed to solving the tasks. The control generative model 106 can assign a contribution score indicating a generative model’s contribution to solving the task. Thus, the control generative model 106 can select a generative model for solving a particular task or subtask based on the contribution scores of the generative models for solving previous tasks. In some implementations, the control generative model 106 can decide arbitrarily to include or exclude some generative models for solving the previous tasks. The control generative model can compare the performance of the generative models for solving the same or similar types of tasks in order to determine how each generative model contributed to solving the tasks.

[88] In some implementations, the control data 108 can cause the target generative model to generate the output at the intemiediate step that indicates no change to the context data. The system 100 can provide a prompt input to the control generative model 106, and the prompt input can request the control generative model to generate control data 108 indicating the target generative model should not generate an output at the current step. For example, if context data 104 indicates that the target generative model is not useful for generating an output at the current stage, the control generative model 106 can generate control data 108 that causes the target generative model to skip generating an output, which may result in no change to the context data 104 for the next step.

[89] In some implementations, if the control generative model 106 determines that none of the generative models are generating helpful outputs for solving the task, e.g., the conversation is stuck, the control generative model 106 can stop all the generative models from generating generative outputs while requesting the user to provide feedback. In some implementations, the control generative model 106 can generate control data 108, and the control data 108 can include a prompt that can be parsed by generative models indicating that none of them should generate outputs.

[90] In some implementations, the control generative model 106 can determine that a generative model is not generating helpful outputs through a critique prompt. The control generative model can use a prompt: “on a scale of 1-10, how helpful this response was to solve the task” or “which parts of this conversation were key reasoning steps to solve the task.”

[91] In some implementations, the control generative model 106 can determine that none of the generative models are generating helpful outputs for solving the task through summarizing the task solving state. If multiple rounds of conversations between generative models lead to the same summary with regard to the task solving state, the control generative model can determine that the generative models are not helpful and have not made progress towards generating helpful information.

[92] The control generative model can stop all the generative models from generating generative outputs in multiple ways. In some implementations, the control generative model that controls streamed decoding of the generative models can stop the streaming of the decoding. In some implementations, the control generative model can generate a stop signal and the generative model can be configured to check for a stop signal before generating generative outputs. If the generative model receives the stop signal, the generative model is not going to generate an output. In some implementations, after a few steps, the control generative model can generate prompts that can be provided as input to the generative models to stop them from generating generative outputs. In some implementations, the control generative model can generate control data that closes a network that connects the generative models to the system.

[93] In some implementations, the control generative model 106 can predict the likely role of each generative model based on the stated goals of the task, the likely interactions between the generative models, the likely interactions between the generative models and the user, or a combination of these. The system 100 can provide a prompt input to the control generative model 106, and the prompt input can request the control generative model to generate control data 108 indicating the predicted likely role of each generative model based on the stated goals of the task, the predicted likely interactions between the generative models, predicted likely the interactions between the generative models and the user, or a combination of these. The control generative model 106 can provide the control data 108 to the target generative model and the target generative model can process the control data 108 to generate a generative output 112 according to the predicted likely role of each generative model based on the stated goals of the task, the predicted likely interactions between the generative models, predicted likely the interactions between the generative models and the user, or a combination of these.

[94] For example, the control generative model 106 can predict that Agent 5 is likely specialized in performing a web search because the user was satisfied with previous search results provided by Agent 5 and was not happy about the previous search results provided by Agent 3. The control generative model 106 can generate control data that causes Agent 3 to provide input to Agent 5 and causes Agent 5 to perform a search based on the input from Agent 3. Then, the control generative model 106 can generate control data that causes Agent 3 to perform further processing for the task based on the search result generated by Agent 5. [95] In some implementations, the multi-agent system 100 can simultaneously process inputs for two or more tasks from multiple users. The control generative model 106 can segment the conversation into multiple threads respectively for each task and can track the conversation flows independently for the multiple tasks. The system 100 can provide a prompt input to the control generative model 106, and the prompt input can request the control generative model to generate control data 108 that segments the conversation into multiple threads respectively for each task and tracks the conversation flows independently for the multiple tasks. The control generative model 106 can generate respective control data for each of the two or more tasks. The system 100 can provide a prompt input to the control generative model 106, and the prompt input can request the control generative model to generate respective control data for each of the two or more tasks.

[96] The control generative model 106 can provide the context data 104 for the task at the current step and the control data 108, to the target generative model 110 in the group. For example, the control generative model 106 can provide the context data 104(1) and the control data 108(1) as inputs to the first generative model 110(1). As another example, the control data 108 can include hyperparameters that define how outputs are generated using the first generative model, e.g., parameters defining the beam size. The first generative model can use the hyperparameters to generate a generative output.

[97] In some implementations, the group of generative models can be language-based models, such as LLMs. The interface for interactions between the control generative model 1 6 and the group of generative models 1 10 can be natural language. In some implementations, other forms of interfaces are possible.

[98] In some implementations, the control generative model 106 can include the context data 104 and the control data 108 in the input to the target generative model, e.g., in the form of a prompt. For example, a prompt to the first generative model 110 can include the input 102 for the task, the context data 104(1) that includes the conversation history, and control data 108(1) that limits the generative output 112(1) to a maximum of three sentences.

[99] In some implementations, the control generative model 106 can set one or more parameters of the target generative model based on the control data 108. For example, the parameters of the target generative model can include the number of tokens in the generative output 112(1) from the first generative model 110(1) and the control generative model 106 can set this parameter based on the control data 108.

[100] In some implementations, the context data 104(1) provided to the first generative model 110(1) can be the same as the context data 104 that is processed by the control generative model 106 to generate the control data 108(1). In some implementations, the context data 104(1) provided to the first generative model 110(1) can be different from the context data 104 that are processed by the control generative model 106 to generate the control data 108(1). For example, the context data 104(1) can include a portion of the context data 104 that are helpful for generating the generative output 112(1) at the step n.

[101] The target generative model 110 can generate a generative output 112 at the current step. For example, based on the context data 104(1) and the control data 108(1) that limits or defines the number of tokens in the output from the first generative model, the first generative model 110(1) can generate a generative output 112(1) at step n. The number of tokens in the generative output 112(1) satisfies the limitation or definition provided in the control data 108(1). As another example, based on the context data 104(2) and the semantic control data 108(2), the second generative model 1 10(2) can generate a generative output 1 12(2) at step n+1 that focuses on the aspect of the task characterized in the semantic control data 108(2).

[102] The control generative model 106 can obtain the generative output 112 from the target generative model. The control generative model 106 can update the context data 104 for the task based on the generative output 112 for use in the step after the current step.

[103] For example, the control generative model 106 can obtain the generative output 112(1) generated by the first generative model 110(1) at step n, and can update the context data 104 for the task based on the generative output 112(1) generated at step n. At step n+1, the control generative model 106 can generate the control data 108(2) for the second generative model 1 10(2) based on the updated context data 104 that has been updated based on the generative output 112(1) generated at step n.

[104] In some implementations, at the end of each step and after obtaining the generative output 112 from the target generative model, the control generative model 106 can predict a progress score indicating a level of progress towards completion of the task. The system 100 can provide a prompt input to the control generative model 106, and the prompt input can request the control generative model to predict a progress score indicating a level of progress towards completion of the task. In some implementations, the control generative model 106 can generate a confidence level for the predicted progress score. The progress score can range between 0 to 100 percent completion. The confidence level can be in percentage or in real numbers.

[105] For example, at the end of step n and after obtaining the generative output 112(1) from the first generative model, the control generative model 106 can generate a predicted progress score of 80%, indicating that the level of progress towards completion of the task is 80%, and the confidence level for the predicted progress score can be 70%.

[106] In some implementations, the control generative model 106 can determine the progress score based on a user input. In some implementations, the user input can include explicit feedback regarding whether the task or a subtask of the task is completed. In some implementations, the user input can include action data of a user that indirectly indicates whether the task is completed. For example, after receiving an output generated from a generative model in response to a prompt asking the generative model to solve a subtask, if the context data 104 indicates that the user performed additional research and analysis for the subtask, the control generative model 106 can predict that the particular subtask is not done. The system 100 can provide a prompt input (e.g., a prompt input including the context data 104 indicating that the user performed additional research and analysis for the task) to the control generative model 106, and the prompt input can request the control generative model to predict whether the particular subtask is completed or not.

[107] Based on the predicted progress score and optionally, its confidence level, the control generative model 106 can determine whether the task has been completed. If the control generative model 106 determines that the task is not completed, the control generative model 106 can include the predicted progress score and optionally, its confidence level, in the context data 104 for the task at the next step.

[108] After a plurality of steps, the control generative model 106 can determine that the task is completed, e.g., based on the predicted progress score and optionally, its confidence level. For example, after receiving the final output 114 from a generative model from the group of generative models at the final step, the control generative model 106 can determine that the task is completed. The control generative model 106 can provide the final output 114 for the task to a device, e.g., displaying the final output 114 on a display screen of a mobile device.

[109] FIG. 2 is an example user interface (UI) 200 displaying a conversation generated by multiple generative models controlled by a control generative model.

[HO] The system receives an input 202 for a task of “Please book hotel and flight for my travel to City ABC from April 1-5.” The system can process the input 202 by an agent for hotel booking and an agent for flight booking. The agent for hotel booking implements a hotel booking generative model. The agent for flight booking implements a flight booking generative model. The system can process the input 202 by the two agents across multiple steps, such as step 1. step 2, . . . , step N-l, and Step N. At each step, either the agent for hotel booking or the agent for flight booking generates a generative output. After the multiple steps are completed, the system can obtain a final output 206 for the task, e.g., a hotel has been booked and a flight has been booked.

[Hl] Sometimes, without the control generative model described in this specification, the interactions between the group of generative models can go out of control. For example, one or more generative models may dominate the conversation, diverge in a wrong direction, or focus on irrelevant details, resulting in significant computational cost and being counterproductive.

[112] For example, for the ’‘hotel and flight booking task” in FIG. 2, the agent for flight booking dominates the conversation by asking too many questions in step 2, step 3, and step 4. The agent for flight booking diverges the conversation in the wrong direction by asking “would you like to read some news for City ABC?” in step 3 and “are you interested in traveling by train?” in step 4.

[113] The system can use a control generative model to manage and control the outputs generated from multiple generative models for a task. At an intermediate step, the control generative model can obtain context data for the task at the current step. The context data can include respective previous output generative by one or more generative models in the group at one or more previous steps before the current step. For example, the context data 204 for the task at step 5 can include previous output generated by the agent for hotel booking and agent for flight booking at steps 1-4.

[114] Based on the context data 204 indicating that the agent for flight booking has been generating irrelevant outputs in previous steps 1 -4, the control generative model can select the Agent for hotel booking as the target generative model for generating a generative output at step 5A. The control generative model can allow the agent for flight booking to generate outputs related to flight booking after the hotel booking task is completed. For example, at step 5 A, the agent for hotel booking can generate an output of “which area of City ABC will you be staying in?”, while the agent for flight booking is silent at step 5 A.

[115] In some examples, based on the context data 204 indicating that the agent for flight booking has been diverging the conversation in previous steps 1-4, the control generative model can select the Agent for flight booking as the target generative model for generating a generative output at step 5B and can generate semantic control data that causes the generative output generated from the Agent for flight booking to focus on booking the flight.

[116] For example, at step 5B, the control data can include semantic control data that causes the Agent for flight booking to generate an output that focuses on the flight booking aspect of the task, without diverging the conversation to providing news or other transportation methods to the user. Therefore, at step 5B, the agent for flight booking can generate an output of “‘One-way or round-way flight?”, which focuses on the flight booking task.

[117] In some implementations, the control generative model can generate control data based on a user input. For example, the user provided “Not interested” in the UI 200 in response to the “Are you interested in traveling by train?” output generated by the Agent for Flight booking at step 4. The control generative model 106 can generate semantic control data 108 that causes the Agent for flight booking to generate outputs focusing on the flight booking aspect of the task.

[118] FIG. 3A is a flow chart of an example process 300A for controlling the participation of two or more generative models. FIG. 3B is a flow chart of an example process 3B performed at each intermediate step of a plurality of steps for controlling the participation of two or more generative models. The processes 300A and 300B will be described as being performed by an appropriately programmed computer system, such as the system 100.

[119] The system receives an input for a task to be processed by a group of generative models to generate a final output for the task (302). The system processes the input by the group of the generative models across a plurality of steps (304). A respective generative model in the group generates a generative output at each step of the plurality of steps.

[120] At the first step, after receiving the input for the task, the system can provide the input to one or more generative models directly without using the control generative model to control the participation of the generative models. The one or more generative models can generate initial generative outputs in response to the input for the task. The system can include the initial generative outputs in the context data that can be later used as input to the control generative model to generate control data. In some implementations, the system can start using the control generative model after the first one or more steps.

[121] For each intermediate step of the plurality of steps, the system obtains context data for the task at the intermediate step (306). In some implementations, the context data can include respective previous output generated by one or more generative models in the group at one or more previous steps before the intermediate step.

[122] In some implementations, the context data can include a progress score indicating a level of progress towards completion of the task. In some implementations, the context data can include a level of importance of the task. In some implementations, the context data can include an amount of compute budget left at the intermediate step for completing the task by the group of the generative models. In some implementations, the context data can include metadata about the group of the generative models. [123] The system generates, based on the context data for the task at the intermediate step, control data for a target generative model in the group (308). The system can provide a prompt input to the control generative model, and the prompt input can request the control generative model to generate control data for the target generative model. In some implementations, the control data can include a compute budget for the target generative model, and the compute budget can define an amount of computational resources that the target generative model consumes in the intermediate step. In some implementations, the control data can define a number of tokens in the output from the target generative model generated at the intermediate step.

[124] In some implementations, the control data can limit the number of tokens in the output from the target generative model generated at the intermediate step, and limiting the number of tokens in the output from the target generative model generated at the intermediate step does not reduce a final progress score for the task. The final progress score can be a measure of an extent to which the task has been completed after the input has been processed across the plurality of steps to generate the final output for the task.

[125] In some implementations, the control data can include semantic control data that causes the target generative model to generate an output that focuses on an aspect of the task. In some implementations, the control data can cause the target generative model to generate the output at the intermediate step that indicates no change to the context data.

[126] In some implementations, for each intermediate step, the system can select, based on the context data for the task at the intermediate step, the target generative model from the group of the generative models. For example, the system can determine which generative model among the group of generative models should generate an output at the current step.

[127] The system provides the context data for the task at the intermediate step and the control data to the target generative model in the group ( 10). The system can provide a prompt input to the target generative model, and the prompt input can include the context data and the control data. The prompt input can request the target generative model to generate a generative output based on the control data and the context data. The target generative model processes the context data and the control data and generates a generative output for the task.

[128] The system obtains an output from the target generative model generated in response to the context data and the control data (312). [129] The system updates the context data for the task based on the output from the target generative model (314). At the next step, the system can generate control data for the next target generative model based on the updated context data.

[130] The system can determine whether the task is completed after receiving the output from the target generative model. If the system determines that the task is not completed, the system can use the next target generative model to generate a generative output for the task at the next step. If the system determines that the task is completed, the system can determine that the output from the target generative model at the current step is the final output and the system can determine that the current step is the final step. The system can provide the final output for presentation to a user or for further processing based on the final output.

[131] FIG. 4 is a flow chart of an example process 400 for training a control generative model. The process will be described as being performed by an appropriately programmed machine learning training system, e.g., a training system for training a generative model.

[132] The system receives a final output for a task generated by a group of generative models at a final step of a plurality of steps (402). In some implementations, the system can determine that the task is completed after receiving the final output from a generative model at the final step (404).

[133] The system generates training data for training a control generative model based on context data for the task at each of the plurality of steps (406). The training data includes a plurality of training examples. Each training example includes context data for the task and its corresponding ground truth control data. The ground truth control data can be text data, such as a prompt input to a generative model or semantic control data that causes a target generative model to generate an output that focuses on an aspect of the task. The ground truth control data can be a value for a compute budget, such as a number of tokens in an output from a target generative model generated at a step, or decoding parameters, e.g., a beam size.

[134] For each step or some steps of the plurality of steps for completing the task, the system can determine a contribution score for completing the task of a generative output generated by a generative model at a step. For example, the system can determine the contribution score of a generative output based on user feedback in the conversation, or based on comparison of a predicted progress score before and after receiving the generative output. In some implementations, the system can determine the contribution score of a generative output by using a critique generative language model that has been trained to generate an assessment of another language model's output on some underlying tasks and identify flaws in the language model outputs. Based on the contribution for completing the task, the system can determine the ground truth control data for the generative model at the step.

[135] In some implementations, the system can determine the ground truth control data based on a generative model’s contribution score for completing the task. For example, if the contribution score is below a threshold, indicating that a generative model’s contribution for completing the task is not significant, the ground truth control data for the generative model at the step can include less compute budget, e.g., a fewer number of tokens in the output from the generative model. If the contribution score is above a threshold, indicating that a generative model’s contribution for completing the task is significant, the ground truth control data for the generative model at the step can include more compute budget, e g., a greater number of tokens in the output from the generative model.

[136] In some implementations, the system can determine a respective contribution score for completing each of several aspects of the task, e.g., several subtasks, of a generative output generated by a generative model at a step. The system can determine the ground truth control data based on a generative model’s contribution score for completing an aspect of the task.

[137] For example, if a generative model’s contribution score for completing a first aspect of the task is above a threshold and the generative model’s contribution score for completing a second aspect of the task is not above a threshold, indicating that the generative model contributes significantly in the first aspect of the task, but contributes insignificantly in the second aspect of the task, the ground truth control data for the generative model at the step can include semantic control data that causes the generative model to generate output that focuses on the first aspect of the task. For example, the semantic control data can include a prompt input: "‘please only generate a response to the first aspect of the task and do not generate a response to the second aspect of the task.”

[138] The system trains the control generative model using the training data (408). The system can train the control generative model in multiple iterations. At each iteration, for each training example, the system can generate predicted control data using the control generative model with the parameters at the iteration. The system can compute a value for a loss function by comparing the predicted control data with the ground truth control data for the training examples at the iteration.

[139] If the control generative model is a generative language model, at each iteration, the system can feed tokens at the previous iterations using the respective ground truth tokens in the ground truth control data, and the system can generate a probability distribution for the next token at the current iteration based on the ground truth tokens at the previous iterations. The system can compute a value for a loss function that measures the probability assigned to the ground truth next token.

[140] The system can update the parameters for the control generative model based on the value for the loss function, e g., to minimize the value for the loss function. The system can update the parameters for the control generative model in multiple iterations until the training is completed.

[141] In some implementations, the system can train the control generative model through fine-tuning a pre-trained model. The system can train the control generative model through adjustments to parameters of a previously trained model, rather than learning the parameters from scratch. Thus, fine-tuning is less resource-intensive and requires less computational time than training from scratch.

[142] In some implementations, the training system can generate simulated training data for training the control generative model. For example, the training system can convert data that includes step-by-step data for solving a task (e.g., which may or may not involve multiple agents) into a simulated training example for training a control generative model for a multiagent environment. In this training example, each generative model of a group of generative models can generate a part of the solution. In this way, the system can generate a large amount of training data and evaluation data for training the control generative model.

[143] This specification uses the term “configured⁷’ in connection with systems and computer program components. For a system of one or more computers to be configured to perform particular operations or actions means that the system has installed on it software, firmware, hardware, or a combination of them that in operation cause the system to perform the operations or actions. For one or more computer programs to be configured to perform particular operations or actions means that the one or more programs include instructions that, when executed by data processing apparatus, cause the apparatus to perform the operations or actions.

[144] Embodiments of the subject matter and the functional operations described in this specification can be implemented in digital electronic circuitry, in tangibly-embodied computer software or firmware, in computer hardware, including the structures disclosed in this specification and their structural equivalents, or in combinations of one or more of them. Embodiments of the subject matter described in this specification can be implemented as one or more computer programs, i.e., one or more modules of computer program instructions encoded on a tangible non-transitory storage medium for execution by, or to control the operation of, data processing apparatus. The computer storage medium can be a machine- readable storage device, a machine-readable storage substrate, a random or serial access memory device, or a combination of one or more of them. Alternatively or in addition, the program instructions can be encoded on an artificially-generated propagated signal, e.g., a machine-generated electrical, optical, or electromagnetic signal, that is generated to encode information for transmission to suitable receiver apparatus for execution by a data processing apparatus.

[145] The term “data processing apparatus” refers to data processing hardware and encompasses all kinds of apparatus, devices, and machines for processing data, including by way of example a programmable processor, a computer, or multiple processors or computers. The apparatus can also be. or further include, off-the-shelf or custom-made parallel processing subsystems, e.g., a GPU or another kind of special-purpose processing subsystem. The apparatus can also be, or further include, special purpose logic circuitry, e.g., an FPGA (field programmable gate array) or an ASIC (application-specific integrated circuit). The apparatus can optionally include, in addition to hardware, code that creates an execution environment for computer programs, e.g.. code that constitutes processor firmware, a protocol stack, a database management system, an operating system, or a combination of one or more of them.

[146] A computer program which may also be referred to or described as a program, software, a software application, an app. a module, a software module, a script, or code) can be written in any form of programming language, including compiled or interpreted languages, or declarative or procedural languages, and it can be deployed in any form, including as a stand-alone program or as a module, component, subroutine, or other unit suitable for use in a computing environment. A program may, but need not, correspond to a file in a file system. A program can be stored in a portion of a file that holds other programs or data, e.g., one or more scripts stored in a markup language document, in a single file dedicated to the program in question, or in multiple coordinated files, e.g., files that store one or more modules, sub-programs, or portions of code. A computer program can be deployed to be executed on one computer or on multiple computers that are located at one site or distributed across multiple sites and interconnected by a data communication network.

[147] As used in this specification, an “engine,” or “software engine,” refers to a software implemented input/ output system that provides an output that is different from the input. An engine can be an encoded block of functionality, such as a library, a platform, a software development kit (“SDK”), or an object. Each engine can be implemented on any appropriate type of computing device, e.g., servers, mobile phones, tablet computers, notebook computers, music players, e-book readers, laptop or desktop computers, PDAs, smart phones, or other stationary or portable devices, that includes one or more processors and computer readable media. Additionally, two or more of the engines may be implemented on the same computing device, or on different computing devices.

[148] The processes and logic flows described in this specification can be performed by one or more programmable computers executing one or more computer programs to perform functions by operating on input data and generating output. The processes and logic flows can also be performed by special purpose logic circuitry, e.g., an FPGA or an ASIC, or by a combination of special purpose logic circuitry and one or more programmed computers.

[149] Computers suitable for the execution of a computer program can be based on general or special purpose microprocessors or both, or any other kind of central processing unit. Generally, a central processing unit will receive instructions and data from a read-only memory or a random access memory' or both. The essential elements of a computer are a central processing unit for performing or executing instructions and one or more memory’ devices for storing instructions and data. The central processing unit and the memory can be supplemented by, or incorporated in, special purpose logic circuitry'. Generally, a computer will also include, or be operatively coupled to receive data from or transfer data to, or both, one or more mass storage devices for storing data, e.g., magnetic, magneto-optical disks, or optical disks. However, a computer need not have such devices. Moreover, a computer can be embedded in another device, e.g., a mobile telephone, a personal digital assistant (PDA), a mobile audio or video player, a game console, a Global Positioning System (GPS) receiver, or a portable storage device, e.g., a universal serial bus (USB) flash drive, to name just a few.

[150] Computer-readable media suitable for storing computer program instructions and data include all forms of non-volatile memory, media and memory devices, including by way of example semiconductor memory⁷ devices, e.g., EPROM, EEPROM, and flash memory devices; magnetic disks, e.g., internal hard disks or removable disks; magneto-optical disks; and CD-ROM and DVD-ROM disks.

[151] To provide for interaction with a user, embodiments of the subject matter described in this specification can be implemented on a computer having a display device, e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor, for displaying information to the user and a keyboard and pointing device, e.g., a mouse, trackball, or a presence sensitive display or other surface by which the user can provide input to the computer. Other kinds of devices can be used to provide for interaction with a user as well; for example, feedback provided to the user can be any form of sensory feedback, e.g., visual feedback, auditory feedback, or tactile feedback; and input from the user can be received in any form, including acoustic, speech, or tactile input. In addition, a computer can interact with a user by sending documents to and receiving documents from a device that is used by the user; for example, by sending web pages to a web browser on a user’s device in response to requests received from the web browser. Also, a computer can interact with a user by sending text messages or other forms of message to a personal device, e.g.. a smartphone, running a messaging application, and receiving responsive messages from the user in return.

[152] While this specification contains many specific implementation details, these should not be construed as limitations on the scope of any invention or on the scope of what may be claimed, but rather as descriptions of features that may be specific to particular embodiments of particular inventions. Certain features that are described in this specification in the context of separate embodiments can also be implemented in combination in a single embodiment. Conversely, various features that are described in the context of a single embodiment can also be implemented in multiple embodiments separately or in any suitable subcombination. Moreover, although features may be described above as acting in certain combinations and even initially be claimed as such, one or more features from a claimed combination can in some cases be excised from the combination, and the claimed combination may be directed to a subcombination or variation of a subcombination.

[153] Similarly, while operations are depicted in the drawings in a particular order, this should not be understood as requiring that such operations be performed in the particular order shown or in sequential order, or that all illustrated operations be performed, to achieve desirable results. In certain circumstances, multitasking and parallel processing may be advantageous. Moreover, the separation of various system modules and components in the embodiments described above should not be understood as requiring such separation in all embodiments, and it should be understood that the described program components and systems can generally be integrated together in a single software product or packaged into multiple software products.

[154] Particular embodiments of the subject matter have been described. Other embodiments are within the scope of the following claims. For example, the actions recited in the claims can be performed in a different order and still achieve desirable results. As one example, the processes depicted in the accompanying figures do not necessarily require the particular order shown, or sequential order, to achieve desirable results. In some cases, multitasking and parallel processing may be advantageous.

Claims

1. A method performed by one or more computers, the method comprising: receiving an input for a task to be processed by a group of generative models to generate a final output for the task; and processing the input by the group of the generative models across a plurality of steps, wherein a respective generative model in the group generates a generative output at each step of the plurality of steps, and processing the input comprises, for each intermediate step of the plurality of steps, obtaining, by a control generative model, context data for the task at the intermediate step; generating, by the control generative model and based on the context data for the task at the intermediate step, control data for a target generative model in the group; providing, by the control generative model, the context data for the task at the intermediate step and the control data to the target generative model in the group; obtaining, by the control generative model, an output from the target generative model generated in response to the context data and the control data; and updating, by the control generative model, the context data for the task based on the output from the target generative model.

2. The method of claim 1, wherein the control data comprises a compute budget for the target generative model, and the compute budget defines an amount of computational resources that the target generative model consumes in the intermediate step.

3. The method of claim 1 or 2, wherein the control data defines a number of tokens in the output from the target generative model generated at the intermediate step.

4. The method of any of claims 1-3, wherein the control data limits the number of tokens in the output from the target generative model generated at the intermediate step, and wherein limiting the number of tokens in the output from the target generative model generated at the intermediate step does not reduce a final progress score for the task, the final progress score being a measure of an extent to which the task has been completed after the input has been processed across the plurality of steps to generate the final output for the task.

5. The method of any of claims 1-4, wherein the control data comprises semantic control data that causes the target generative model to generate an output that focuses on an aspect of the task.

6. The method of any of claims 1-5, wherein the control data causes the target generative model to generate the output at the intermediate step that indicates no change to the context data.

7. The method of any of claims 1-6, comprising: for each intermediate step, selecting, by the control generative model and based on the context data for the task at the intermediate step, the target generative model from the group of the generative models.

8. The method of any of claims 1-7, wherein the context data comprises respective previous output generated by one or more generative models in the group at one or more previous steps before the intermediate step.

9. The method of any of claims 1-8, wherein the context data comprises a progress score indicating a level of progress towards completion of the task.

10. The method of any of claims 1-9, wherein the context data comprises a level of importance of the task.

11. The method of any of claims 1-10, wherein the context data comprises an amount of compute budget left at the intermediate step for completing the task by the group of the generative models.

12. The method of any of claims 1-11, wherein the context data comprises metadata about the group of the generative models.

13. The method of any of claims 1-12, further comprising: receiving the final output for the task generated by the group of the generative models at a final step of the plurality of steps; generating training data for training the control generative model based on the context data for the task at each of the plurality of steps; and training the control generative model using the training data.

14. The method of claim 13, comprising: determining, by the control generative model, that the task is completed after receiving the final output from a generative model at the final step.

15. A system comprising one or more computers and one or more storage devices storing instructions that are operable, when executed by the one or more computers, to cause the one or more computers to perform operations comprising: receiving an input for a task to be processed by a group of generative models to generate a final output for the task; and processing the input by the group of the generative models across a plurality of steps, wherein a respective generative model in the group generates a generative output at each step of the plurality of steps, and processing the input comprises, for each intermediate step of the plurality of steps, obtaining, by a control generative model, context data for the task at the intermediate step; generating, by the control generative model and based on the context data for the task at the intermediate step, control data for a target generative model in the group; providing, by the control generative model, the context data for the task at the intermediate step and the control data to the target generative model in the group: obtaining, by the control generative model, an output from the target generative model generated in response to the context data and the control data; and updating, by the control generative model, the context data for the task based on the output from the target generative model.

16. The system of claim 15, wherein the control data comprises a compute budget for the target generative model, and the compute budget defines an amount of computational resources that the target generative model consumes in the intermediate step.

17. The system of claim 15 or 16, wherein the control data defines a number of tokens in the output from the target generative model generated at the intermediate step.

18. The system of any of claims 15 to 17, wherein the control data limits the number of tokens in the output from the target generative model generated at the intermediate step, and wherein limiting the number of tokens in the output from the target generative model generated at the intermediate step does not reduce a final progress score for the task, the final progress score being a measure of an extent to which the task has been completed after the input has been processed across the plurality of steps to generate the final output for the task.

19. The system of any of claims 15-18, wherein the control data comprises semantic control data that causes the target generative model to generate an output that focuses on an aspect of the task.

20. One or more non-transitory storage media encoded with instructions that when executed by a computing device cause the computing device to perform operations comprising: receiving an input for a task to be processed by a group of generative models to generate a final output for the task; and processing the input by the group of the generative models across a plurality of steps, wherein a respective generative model in the group generates a generative output at each step of the plurality of steps, and processing the input comprises, for each intermediate step of the plurality of steps, obtaining, by a control generative model, context data for the task at the intermediate step; generating, by the control generative model and based on the context data for the task at the intermediate step, control data for a target generative model in the group; providing, by the control generative model, the context data for the task at the intermediate step and the control data to the target generative model in the group; obtaining, by the control generative model, an output from the target generative model generated in response to the context data and the control data; and updating, by the control generative model, the context data for the task based on the output from the target generative model.