Notice of Pre-AIA or AIA Status
The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA .
Status of Claims
This is in response to applicant’s filing date of March 14, 2025, filed with preliminary amendment. In the preliminary amendment claim 13 was cancelled and claims 15-21 were added. Claims 1-12 and 14-21 are currently pending.
Information Disclosure Statement
The information disclosure statement (IDS) submitted on November 14, 2025, is in compliance with the provisions of 37 CFR 1.97. Accordingly, the information disclosure statement is being considered by the examiner.
Priority
Regarding U.S. Provisional Patent Application Nos. 63/407607, filed September 16, 2022, Applicant’s claim for the benefit of a prior-filed application under 35 U.S.C. 119(e) or under 35 U.S.C. 120 is acknowledged.
Priority to Prior-Filed Application
Applicant’s claim for the benefit of a prior-filed application, PCT/US2023/033047 filed on 09/18/2023, under 35 U.S.C. 119(e) or under 35 U.S.C. 120, 121, 365(c), or 386(c) is acknowledged.
Claim Rejections -- 35 U.S.C. § 103
The following is a quotation of 35 U.S.C. 103 which forms the basis for all obviousness rejections set forth in this Office action:
A patent for a claimed invention may not be obtained, notwithstanding that the claimed invention is not identically disclosed as set forth in section 102, if the differences between the claimed invention and the prior art are such that the claimed invention as a whole would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to which the claimed invention pertains. Patentability shall not be negated by the manner in which the invention was made.
The factual inquiries for establishing a background for determining obviousness under 35 U.S.C. 103 are summarized as follows:
1. Determining the scope and contents of the prior art.
2. Ascertaining the differences between the prior art and the claims at issue.
3. Resolving the level of ordinary skill in the pertinent art.
4. Considering objective evidence present in the application indicating obviousness or nonobviousness.
This application currently names joint inventors. In considering patentability of the claims the examiner presumes that the subject matter of the various claims was commonly owned as of the effective filing date of the claimed invention(s) absent any evidence to the contrary. Applicant is advised of the obligation under 37 CFR 1.56 to point out the inventor and effective filing dates of each claim that was not commonly owned as of the effective filing date of the later invention in order for the examiner to consider the applicability of 35 U.S.C. 102(b)(2)(C) for any potential 35 U.S.C. 102(a)(2) prior art against the later invention.
Claims 1-12 and 14-21 are rejected under 35 U.S.C. 103 as being unpatentable over Hermann et al (US-20210110115-A1)(“Hermann”) in view of Liang et al (NPL:” Code as Policies: Language Model Programs for Embodied Control”)(“Liang”), provided by Applicant in the IDS filed on 11/14/2025.
As per claim 1, Hermann discloses a method for controlling a robot (Figure 2), the method comprising:
obtaining a natural language instruction for interacting with the robot (Hermann at Para. [0057] discloses receiving a natural language instruction for the robot (agent) to perform a particular function:” system as described in this specification can be trained to select actions which cause an agent interacting with an environment to execute written instructions specified by text strings. Thereby, the system can learn to comprehend the meaning of natural language by relating natural language text strings to the environment. More specifically, the system can learn to relate the components (e.g., words and phrases) of natural language text strings to observations of the environment and to pertinent sequences of actions.”);
generating an input sequence (Hermann at Para. [0077] discloses processing and generating an input sequence:” system 100 processes a representation of the current text string 108 using a language encoder model 116 (which can also be referred to as a “language encoder module”) to generate a current text embedding 118.”) that comprises:
(i) the natural language instruction (Hermann at Para. [0077] discloses that input sequence includes the natural language instruction:” the representation of the current text string 108 may be a sequence of numerical representations, where each numerical representation represents a respective character (or word) from a dictionary of possible characters (or words), and the current text embedding 118 may be a feature vector representing the current text string 108.”), and
(ii) a context sequence that specifies one or more application programming interfaces (APIs) that can be called to obtain outputs generated from one or more sensors of the robot, to control the robot, or both (Hermann at Para. [0078] discloses combining the text instructions and observations to specify the actions to be performed by an agent:” the system 100 combines the current observation embedding 114 and the current text embedding 118 to determine a current combined embedding 120, and uses the current combined embedding 120 to select an action 102 to be performed by the agent 104 in response to the current observation 110.”);
, ;
; and
executing the computer program to interact with the robot (Hermann at Para. [0124] discloses executing a computer program to perform certain actions:” 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.”).
Hermann does not explicitly disclose the processing of an input so as to generate as output a computer code sequence in a programming language that defines a computer program and then generating a computer program the computer code sequence.
Hermann does not disclose, but Liang discloses processing the input sequence using a code generation neural network to generate as output a computer code sequence in a programming language that defines a computer program , the computer code sequence comprising computer code representing a call to one of the one or more APIs and arguments for the call (Liang at Page 2 discloses using a language model to generate computer code for an agent/robot:” instruction-to-code pairs that present few-shot "demonstrations" of how natural language instructions should be converted into code. These may include performing arithmetic, calling other APIs, and other features of the programming language. Instructions are written as comments directly preceding a block of corresponding solution code. We can maintain an LMP "session" by incrementally appending new instructions and responses to the prompt, allowing later instructions to refer back to previous instructions, like "undo the last action".”).
Hermann does not disclose, but Liang discloses generating, from the computer code sequence, the computer program (Liang at Page 2 discloses generating a computer program (Python) from the input sequence:” Python code-writing LLMs store knowledge of many popular libraries. LMPs can be prompted to use these libraries to perform complex instructions without writing all of the code e.g., using NumPy to elicit spatial reasoning with coordinates. Hints here include import statements, and Examples define cardinal directions. Variable names are also important to indicate that pts_np and pt_np are NumPy arrays. Operations with 2D vectors imply that the points are also 2D.”).
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to implement the disclosed code writing LLMs to write robot policy code from natural language commands taught in Liang in the robot controllers in Hermann with a reasonable expectation of success because this results in the robots being utilized to link words, percepts, and actions enabling applications in human-robot interaction using large language model prompts (see Liang at Page 3, section on “Prompting Language Model Programs”.).
As per claim 2, Hermann and Liang disclose a method of claim 1, wherein the input sequence further comprises one or more example sequences that each comprise:
(i) an example natural language instruction (Liang at Page discloses natural language instructions as example to the large language model:” Examples are instruction-to-code pairs that present few-shot "demonstrations" of how natural language instructions should be converted into code. These may include performing arithmetic, calling other APIs, and other features of the programming language. Instructions are written as comments directly preceding a block of corresponding solution code.”), and(ii) an example computer code sequence in the programming language generated in response to the example natural language instruction (Liang at Page 3 disclosing producing examples in the computer language (Python):” LMPs are perhaps best understood through examples, to which the following section builds up from simple pure-Python instructions to more complex ones that can complete robot tasks. These examples use OpenAI Codex code-davinci-002 with temperature 0 (i.e., deterministic greedy token decoding). Here, the prompt (in gray) starts with a Hint to indicate we are writing Python.”).
As per claim 3, Hermann and Liang disclose a method of claim1, wherein generating, from the computer code sequence, the computer program comprises:
determining that the computer code sequence includes first computer code that calls a function that is undefined (Liang at Page 4 discloses generating an undefined code sequence:” Function generation can be implemented by parsing the code generated by an LMP, locating yet-to-be-defined functions, and calling another LMP specialized in function-generation to create those functions. This allows both the prompt and the code generated by LMPs to call yet-to-be-defined functions.”); and
in response (Liang at Page 4):
generating a new input sequence that comprises a natural language instruction to define the function (Liang at Page 3 generates an input sequence to try to define the function:” high-level LMP generates high-level policy behavior and relies … Then, parse_obj uses get_objs_bigger_than_area_th (yet-tobe- defined function), to complete the query. This function is given through an import statement in the Hints of the parse_obj prompt, but it is not implemented. on parse_obj to get object names by language descriptions:”); and
processing the new input sequence using the code generation neural network to generate a new output sequence that comprises new computer code that defines the function (Liang at Page 2 discloses that language model program generate computer program be recursively defining the prompts to generate the computer code for the robot:” LMPs can be hierarchical: prompted to recursively define new functions, accumulate their own libraries over time, and self architect a dynamic code base. We demonstrate across several robot systems that LLMs can autonomously interpret language commands to generate LMPs that represent reactive low-level policies (e.g., PD or impedance controllers), and waypoint-based policies (e.g., for vision-based pick and place, or trajectory-based control).”).
As per claim 4, Hermann and Liang disclose a method of claim 3, wherein generating, from the computer code sequence, the computer program comprises:
generating a modified computer code sequence that replaces the first computer code with the new computer code (Liang at Page 1, discloses the generation of Python code from the natural language(docstring):” LLMs trained on code-completion have shown to be capable of synthesizing Python programs from docstrings.”).
As per claim 5, Hermann and Liang disclose a method of claim 1, wherein executing the computer program to interact with the robot comprises:
calling an execution function for the programming language with an input string derived from the computer code sequence (Liang at Page 3, method, discloses calling an execution function from the input string:” Input instructions are formatted as comments (green),which can be provided by humans or written by another LMP. Predicted outputs from the LLM (highlighted) are expected to be valid Python code, generated autoregressively [11], [12]. LMPs are few-shot prompted with examples to generate different subprograms that may process object detection results, build trajectories, or sequence control primitives.”).
As per claim 6, Hermann and Liang disclose a method of claim 5, wherein calling the execution function further comprises: calling the execution function with: (i) a global dictionary that specifies at least the one or more APIs, and(ii) a local dictionary that can be populated with at least variables defined during the execution (Liang at Page 3, method, discloses calling certain functions by using a global and local dictionaries:” we call Python’s exec function with the code as the input string and two dictionaries that form the scope of that code execution: (i) globals, containing all APIs that the generated code might call, and (ii) locals, an empty dictionary which will be populated with variables and new functions defined during exec. If the LMP is expected to return a value, we obtain it from locals after exec finishes.”).
As per claim 7, Hermann and Liang disclose a method of claim 6, the method further comprising: after executing the computer program, providing one or more values from the local dictionary in response the natural language instruction (Liang at Page 3, discloses that the local dictionary is defined after execution of the program:” populated with variables and new functions defined during exec. If the LMP is expected to return a value, we obtain it from locals after exec finishes.”).
As per claim 8, Hermann and Liang disclose a method of claim 3, wherein generating the computer program comprises adding data specifying the new computer code that defines the function to a global dictionary, a local dictionary, or both (Liang at Page 3 discloses adding data and functions to the local dictionary which is build from the execution of the program:” empty dictionary which will be populated with variables and new functions defined during exec”.).
As per claim 9, Hermann and Liang disclose a method of claim 1, wherein the computer code sequence comprises computer code representing a call to a library for the programming language that is not specified in the context sequence (Liang at Page 9 discloses the use of library calls that need not be specified in the input string:” third party libraries, including import statements in the prompt may not be necessary, as we found that LMP scan generate code that calls NumPy and SciPy without them. However, explicit import statements do improve reliability and increase the chance of LMPs using those libraries when the need arises. For using first party libraries, meaningful function names that follow popular conventions (e.g., begin with set_ and get_)and specify return object formats (e.g., get_bbox_xyxy) induce more accurate usages.”).
As per claim 10, Hermann and Liang disclose a method of claim 1, wherein the code generation neural network is an auto-regressive neural network that auto-regressively generates each computed code token in the computer code sequence conditioned on the input sequence (Hermann at Para. [0024] discloses the use of an auto-regressive neural network:” determining the one or more auxiliary outputs includes predicting a next observation to be received after the agent performs the selected action using a temporal autoencoder neural network that receives as input an embedding of the selected action and the current observation embedding.”).
As per claim 11, Hermann and Liang disclose a method of claim 10, wherein the code generation neural network is a Transformer neural network (Hermann at Para. [0025] discloses the use of an autoencoder that under the broadest of interpretation would perform the function of transforming the input at the neural network:” determining the auxiliary update includes obtaining an actual next observation. An update to the current values of the parameters of the observation encoding neural network is determined by performing an iteration of gradient descent to minimize a loss between the actual next observation and the predicted next observation.”).
As per claim 12, Hermann and Liang disclose a method of claim 1, wherein the code generation neural network has been trained on a language modeling objective on a corpus of training computer code sequences from training computer programs (Liang at Page 1, introduction, discloses that the model is trained by a corpus of training computer code:” recent progress in natural language processing shows that large language models (LLMs) pretrained on Internet scale data [11]–[13] exhibit out-of-the-box capabilities [14]–[16]that can be applied to language-using robots e.g., planning a sequence of steps from natural language instructions [16]–[18]without additional model finetuning. These steps can be grounded in real robot affordances from value functions among a fixed set of skills i.e., policies pretrained with behavior cloning or reinforcement learning [19]–[21].”).
As per claim 14, Hermann discloses One or more non-transitory computer storage media storing instructions that when executed by one or more computers cause the one or more computers to perform operations for controlling a robot (Para. [0125]), the operations comprising:
obtaining a natural language instruction for interacting with the robot (Hermann at Para. [0057] discloses receiving a natural language instruction for the robot (agent) to perform a particular function:” system as described in this specification can be trained to select actions which cause an agent interacting with an environment to execute written instructions specified by text strings. Thereby, the system can learn to comprehend the meaning of natural language by relating natural language text strings to the environment. More specifically, the system can learn to relate the components (e.g., words and phrases) of natural language text strings to observations of the environment and to pertinent sequences of actions.”);
generating an input sequence (Hermann at Para. [0077] discloses processing and generating an input sequence:” system 100 processes a representation of the current text string 108 using a language encoder model 116 (which can also be referred to as a “language encoder module”) to generate a current text embedding 118.”) that comprises:
(i) the natural language instruction (Hermann at Para. [0077] discloses that input sequence includes the natural language instruction:” the representation of the current text string 108 may be a sequence of numerical representations, where each numerical representation represents a respective character (or word) from a dictionary of possible characters (or words), and the current text embedding 118 may be a feature vector representing the current text string 108.”), and
(ii) a context sequence that specifies one or more application programming interfaces (APIs) that can be called to obtain outputs generated from one or more sensors of the robot, to control the robot, or both (Hermann at Para. [0078] discloses combining the text instructions and observations to specify the actions to be performed by an agent:” the system 100 combines the current observation embedding 114 and the current text embedding 118 to determine a current combined embedding 120, and uses the current combined embedding 120 to select an action 102 to be performed by the agent 104 in response to the current observation 110.”);
, ;
; and
executing the computer program to interact with the robot (Hermann at Para. [0124] discloses executing a computer program to perform certain actions:” 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.”).
Hermann does not explicitly discloses the processing of an input so as to generate as output a computer code sequence in a programming language that defines a computer program and then generating a computer program the computer code sequence.
Hermann does not disclose, but Liang discloses processing the input sequence using a code generation neural network to generate as output a computer code sequence in a programming language that defines a computer program , the computer code sequence comprising computer code representing a call to one of the one or more APIs and arguments for the call (Liang at Page 2 discloses using a language model to generate computer code for an agent/robot:” instruction-to-code pairs that present few-shot "demonstrations" of how natural language instructions should be converted into code. These may include performing arithmetic, calling other APIs, and other features of the programming language. Instructions are written as comments directly preceding a block of corresponding solution code. We can maintain an LMP "session" by incrementally appending new instructions and responses to the prompt, allowing later instructions to refer back to previous instructions, like "undo the last action".”).
Hermann does not disclose, but Liang discloses generating, from the computer code sequence, the computer program (Liang at Page 2 discloses generating a computer program (Python) from the input sequence:” Python code-writing LLMs store knowledge of many popular libraries. LMPs can be prompted to use these libraries to perform complex instructions without writing all of the code e.g., using NumPy to elicit spatial reasoning with coordinates. Hints here include import statements, and Examples define cardinal directions. Variable names are also important to indicate that pts_np and pt_np are NumPy arrays. Operations with 2D vectors imply that the points are also 2D.”).
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to implement the disclosed code writing LLMs to write robot policy code from natural language commands taught in Liang in the robot controllers in Hermann with a reasonable expectation of success because this results in the robots being utilized to link words, percepts, and actions enabling applications in human-robot interaction using large language model prompts (see Liang at Page 3, section on “Prompting Language Model Programs”.).
As per claim 15 A system comprising one or more computers and one or more storage devices storing instructions that when executed by the one or more computers cause the one or more computers to perform operations for controlling a robot (Figures 1A-1B), the operations comprising:
obtaining a natural language instruction for interacting with the robot (Hermann at Para. [0057] discloses receiving a natural language instruction for the robot (agent) to perform a particular function:” system as described in this specification can be trained to select actions which cause an agent interacting with an environment to execute written instructions specified by text strings. Thereby, the system can learn to comprehend the meaning of natural language by relating natural language text strings to the environment. More specifically, the system can learn to relate the components (e.g., words and phrases) of natural language text strings to observations of the environment and to pertinent sequences of actions.”);
generating an input sequence (Hermann at Para. [0077] discloses processing and generating an input sequence:” system 100 processes a representation of the current text string 108 using a language encoder model 116 (which can also be referred to as a “language encoder module”) to generate a current text embedding 118.”) that comprises:
(i) the natural language instruction (Hermann at Para. [0077] discloses that input sequence includes the natural language instruction:” the representation of the current text string 108 may be a sequence of numerical representations, where each numerical representation represents a respective character (or word) from a dictionary of possible characters (or words), and the current text embedding 118 may be a feature vector representing the current text string 108.”), and
(ii) a context sequence that specifies one or more application programming interfaces (APIs) that can be called to obtain outputs generated from one or more sensors of the robot, to control the robot, or both (Hermann at Para. [0078] discloses combining the text instructions and observations to specify the actions to be performed by an agent:” the system 100 combines the current observation embedding 114 and the current text embedding 118 to determine a current combined embedding 120, and uses the current combined embedding 120 to select an action 102 to be performed by the agent 104 in response to the current observation 110.”);
, ;
; and
executing the computer program to interact with the robot (Hermann at Para. [0124] discloses executing a computer program to perform certain actions:” 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.”).
Hermann does not explicitly discloses the processing of an input so as to generate as output a computer code sequence in a programming language that defines a computer program and then generating a computer program the computer code sequence.
Hermann does not disclose, but Liang discloses processing the input sequence using a code generation neural network to generate as output a computer code sequence in a programming language that defines a computer program , the computer code sequence comprising computer code representing a call to one of the one or more APIs and arguments for the call (Liang at Page 2 discloses using a language model to generate computer code for an agent/robot:” instruction-to-code pairs that present few-shot "demonstrations" of how natural language instructions should be converted into code. These may include performing arithmetic, calling other APIs, and other features of the programming language. Instructions are written as comments directly preceding a block of corresponding solution code. We can maintain an LMP "session" by incrementally appending new instructions and responses to the prompt, allowing later instructions to refer back to previous instructions, like "undo the last action".”).
Hermann does not disclose, but Liang discloses generating, from the computer code sequence, the computer program (Liang at Page 2 discloses generating a computer program (Python) from the input sequence:” Python code-writing LLMs store knowledge of many popular libraries. LMPs can be prompted to use these libraries to perform complex instructions without writing all of the code e.g., using NumPy to elicit spatial reasoning with coordinates. Hints here include import statements, and Examples define cardinal directions. Variable names are also important to indicate that pts_np and pt_np are NumPy arrays. Operations with 2D vectors imply that the points are also 2D.”).
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to implement the disclosed code writing LLMs to write robot policy code from natural language commands taught in Liang in the robot controllers in Hermann with a reasonable expectation of success because this results in the robots being utilized to link words, percepts, and actions enabling applications in human-robot interaction using large language model prompts (see Liang at Page 3, section on “Prompting Language Model Programs”.).
As per claim 16, Hermann and Liang disclose a system of claim 15, wherein the input sequence further comprises one or more example sequences that each comprise: (i) an example natural language instruction (Liang at Page discloses natural language instructions as example to the large language model:” Examples are instruction-to-code pairs that present few-shot "demonstrations" of how natural language instructions should be converted into code. These may include performing arithmetic, calling other APIs, and other features of the programming language. Instructions are written as comments directly preceding a block of corresponding solution code.”), and(ii) an example computer code sequence in the programming language generated in response to the example natural language instruction (Liang at Page 3 disclosing producing examples in the computer language (Python):” LMPs are perhaps best understood through examples, to which the following section builds up from simple pure-Python instructions to more complex ones that can complete robot tasks. These examples use OpenAI Codex code-davinci-002 with temperature 0 (i.e., deterministic greedy token decoding). Here, the prompt (in gray) starts with a Hint to indicate we are writing Python.”).
As per claim 17, Hermann and Liang disclose a system of claim 15, wherein generating, from the computer code sequence, the computer program comprises:
determining that the computer code sequence includes first computer code that calls a function that is undefined (Liang at Page 4 discloses generating an undefined code sequence:” Function generation can be implemented by parsing the code generated by an LMP, locating yet-to-be-defined functions, and calling another LMP specialized in function-generation to create those functions. This allows both the prompt and the code generated by LMPs to call yet-to-be-defined functions.”); and
in response (Liang at Page 4):
generating a new input sequence that comprises a natural language instruction to define the function (Liang at Page 3 generates an input sequence to try to define the function:” high-level LMP generates high-level policy behavior and relies … Then, parse_obj uses get_objs_bigger_than_area_th (yet-tobe- defined function), to complete the query. This function is given through an import statement in the Hints of the parse_obj prompt, but it is not implemented. on parse_obj to get object names by language descriptions:”); and
processing the new input sequence using the code generation neural network to generate a new output sequence that comprises new computer code that defines the function (Liang at Page 2 discloses that language model program generate computer program be recursively defining the prompts to generate the computer code for the robot:” LMPs can be hierarchical: prompted to recursively define new functions, accumulate their own libraries over time, and self architect a dynamic code base. We demonstrate across several robot systems that LLMs can autonomously interpret language commands to generate LMPs that represent reactive low-level policies (e.g., PD or impedance controllers), and waypoint-based policies (e.g., for vision-based pick and place, or trajectory-based control).”).
As per claim 18, Hermann and Liang disclose a system of claim 17, wherein generating, from the computer code sequence, the computer program comprises:
generating a modified computer code sequence that replaces the first computer code with the new computer code (Liang at Page 1, discloses the generation of Python code from the natural language(docstring):” LLMs trained on code-completion have shown to be capable of synthesizing Python programs from docstrings.”).
As per claim 19, Hermann and Liang disclose a system of claim 15, wherein executing the computer program to interact with the robot comprises:
calling an execution function for the programming language with an input string derived from the computer code sequence (Liang at Page 3, method, discloses calling an execution function from the input string:” Input instructions are formatted as comments (green),which can be provided by humans or written by another LMP. Predicted outputs from the LLM (highlighted) are expected to be valid Python code, generated autoregressively [11], [12]. LMPs are few-shot prompted with examples to generate different subprograms that may process object detection results, build trajectories, or sequence control primitives.”).
As per claim 20, Hermann and Liang disclose a system of claim 19, wherein calling the execution function further comprises: calling the execution function with: (i) a global dictionary that specifies at least the one or more APIs, and(ii) a local dictionary that can be populated with at least variables defined during the execution (Liang at Page 3, method, discloses calling certain functions by using a global and local dictionaries:” we call Python’s exec function with the code as the input string and two dictionaries that form the scope of that code execution: (i) globals, containing all APIs that the generated code might call, and (ii) locals, an empty dictionary which will be populated with variables and new functions defined during exec. If the LMP is expected to return a value, we obtain it from locals after exec finishes.”).
As per claim 21, Hermann and Liang disclose a system of claim 20, the method further comprising:
after executing the computer program, providing one or more values from the local dictionary in response the natural language instruction (Liang at Page 3, discloses that the local dictionary is defined after execution of the program:” populated with variables and new functions defined during exec. If the LMP is expected to return a value, we obtain it from locals after exec finishes.”).
Conclusion
The prior art made of record and not relied upon is considered pertinent to applicant's disclosure:
GILLMAN; NATE et al. (US-20240028312-A1) METHODS AND SYSTEMS FOR AUTOMATICALLY GENERATING AND EXECUTING COMPUTER CODE USING A NATURAL LANGUAGE DESCRIPTION OF A DATA MANIPULATION TO BE PERFORMED ON A DATA SET;
Hausman; Karol et al. (US-20230311335-A1) NATURAL LANGUAGE CONTROL OF A ROBOT;
Herzog; Alexander et al. (US-11685045-B1) Asynchronous robotic control using most recently selected robotic action data;
Abramson; Joshua Simon et al. (US-20230178076-A1) CONTROLLING INTERACTIVE AGENTS USING MULTI-MODAL INPUTS;
Kalakrishnan; Mrinal et al. (US-20220105624-A1) EFFICIENT ADAPTION OF ROBOT CONTROL POLICY FOR NEW TASK USING META-LEARNING BASED ON META-IMITATION LEARNING AND META-REINFORCEMENT LEARNING;
Wu; Lingfei et al. (US-20210141863-A1) MULTI-PERSPECTIVE, MULTI-TASK NEURAL NETWORK MODEL FOR MATCHING TEXT TO PROGRAM CODE;
Shah; Pararth et al. (US-20210086353-A1) CONTROLLING A ROBOT BASED ON FREE-FORM NATURAL LANGUAGE INPUT.
Any inquiry concerning this communication or earlier communications from the examiner should be directed to ELLIS B. RAMIREZ whose telephone number is (571)272-8920. The examiner can normally be reached 7:30 am to 5:00pm.
Examiner interviews are available via telephone, in-person, and video conferencing using a USPTO supplied web-based collaboration tool. To schedule an interview, applicant is encouraged to use the USPTO Automated Interview Request (AIR) at http://www.uspto.gov/interviewpractice.
If attempts to reach the examiner by telephone are unsuccessful, the examiner’s supervisor, Ramon Mercado can be reached at 571-270-5744. The fax phone number for the organization where this application or proceeding is assigned is 571-273-8300.
Information regarding the status of published or unpublished applications may be obtained from Patent Center. Unpublished application information in Patent Center is available to registered users. To file and manage patent submissions in Patent Center, visit: https://patentcenter.uspto.gov. Visit https://www.uspto.gov/patents/apply/patent-center for more information about Patent Center and https://www.uspto.gov/patents/docx for information about filing in DOCX format. For additional questions, contact the Electronic Business Center (EBC) at 866-217-9197 (toll-free). If you would like assistance from a USPTO Customer Service Representative, call 800-786-9199 (IN USA OR CANADA) or 571-272-1000.
/ELLIS B. RAMIREZ/Primary Examiner, Art Unit 3658
Prosecution Insights