Datasets:

Barrybw

/

input_thoughts

like 0

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_pizza', 'food_ice_cream', 'mop', 'chair', 'freezer', 'walllamp', 'cat', 'trashcan', 'toothbrush', 'hanger', 'bathroom_counter', 'floor', 'keyboard', 'dining_room', 'bench', 'powersocket', 'cup', 'photoframe', 'novel', 'toothbrush_holder', 'curtain', 'mouse', 'headset', 'pajamas', 'door', 'dishwasher', 'vase', 'tooth_paste', 'clothes_shirt', 'teeth'] Task:Wash teeth response: { thoughts : walk to bathroom, look at the toothbrush holder, grab the toothbrush from the toothbrush holder, find the toothpaste, squeeze the toothpaste into toothbrush, now wash the teeth, actions : ['[WALK] <bathroom>', '[WALK] <toothbrush_holder>', '[FIND] <toothbrush_holder>', '[TURNTO] <toothbrush_holder>', '[LOOKAT] <toothbrush_holder>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[FIND] <tooth_paste>', '[SQUEEZE] <tooth_paste>', '[FIND] <teeth>', '[WASH] <teeth>'] } Scene_Objects:['filing_cabinet', 'food_bread', 'microwave', 'toilet', 'drawing', 'orchid', 'floor', 'phone', 'tea_bag', 'bookshelf', 'plate', 'shower', 'faucet', 'oil', 'candle', 'form', 'dining_room', 'wall', 'basket_for_clothes', 'photoframe', 'bed', 'food_food', 'coffee_filter', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'door', 'dishwasher'] Task:Go to toilet response:

{ I walk into the bath room and go to the toilet }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'bathroom', 'trashcan', 'orchid', 'drawing', 'cpuscreen', 'knifeblock', 'floor', 'dvd_player', 'computer', 'bookmark', 'brush', 'ceilinglamp', 'faucet', 'electric_shaver', 'floor_lamp', 'mousepad', 'wall', 'powersocket', 'novel', 'food_food', 'check', 'television', 'after_shave', 'cupboard', 'sink', 'home_office', 'table', 'tooth_paste'] Task:Turn on light response: { thoughts : Twist the lamp switch until the light goes on., actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>'] } Scene_Objects:['fork', 'pot', 'food_bread', 'microwave', 'walllamp', 'trashcan', 'knife', 'cpuscreen', 'floor', 'phone', 'bookshelf', 'computer', 'toaster', 'ceilinglamp', 'plate', 'shower', 'foundation', 'clothes_pants', 'wall', 'coffe_maker', 'television', 'water', 'kitchen_counter', 'hairbrush', 'cupboard', 'sink', 'spoon', 'bathroom_cabinet', 'light', 'dishwasher'] Task:Wash dishes with dishwasher response:

{ first i will take all the dishes to the dish washer and with the help of dishwasher and water i will clean all the dishes }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'beer', 'toilet', 'dough', 'toothbrush', 'drawing', 'floor', 'ceiling', 'computer', 'ceilinglamp', 'tvstand', 'stereo', 'shower', 'window', 'oil', 'couch', 'bowl', 'wall', 'oven', 'toy', 'cup', 'bed', 'food_food', 'television', 'wooden_spoon', 'towel_rack', 'comb', 'cupboard', 'table', 'dishwasher'] Task:Relax on sofa response: { thoughts : Walk to living room. Find couch. Sit on couch, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>'] } Scene_Objects:['spectacles', 'pot', 'filing_cabinet', 'tablelamp', 'mop', 'toilet', 'walllamp', 'cat', 'drawing', 'floor', 'ceiling', 'character', 'bookshelf', 'food_cake', 'piano_bench', 'shower', 'faucet', 'pillow', 'wall', 'photoframe', 'bed', 'curtain', 'doorjamb', 'diary', 'dresser', 'cupboard', 'door', 'bathroom_cabinet', 'soap', 'instrument_violin'] Task:Go to toilet response:

{ Walk to the bathroom. Find the toilet. Lift the top of the toilet. Sit on the toilet. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'tablelamp', 'microwave', 'toilet', 'chair', 'freezer', 'band-aids', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'character', 'food_bacon', 'mat', 'tvstand', 'shower', 'pillow', 'wall', 'bed', 'photoframe', 'food_food', 'doorjamb', 'console', 'kitchen_counter', 'dresser', 'cupboard', 'door'] Task:Put groceries in Fridge response: { thoughts : I walk in to the kitchen. I open the fridge. I place the groceries in the fridge. I close the fridge., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['pot', 'food_salt', 'crayon', 'chair', 'freezer', 'detergent', 'food_butter', 'drawing', 'knife', 'hanger', 'floor', 'character', 'piano_bench', 'toaster', 'clothes_socks', 'food_peanut_butter', 'pillow', 'food_kiwi', 'coffe_maker', 'food_donut', 'tray', 'curtain', 'shaving_cream', 'mouse', 'kitchen_counter', 'dishrack', 'hair', 'door', 'hairdryer', 'napkin'] Task:Turn on light response:

{ Turning on lights }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'microwave', 'blow_dryer', 'detergent', 'cat', 'drawing', 'desk', 'thread', 'computer', 'button', 'table_cloth', 'ceilinglamp', 'tvstand', 'mousepad', 'broom', 'nightstand', 'oven', 'powersocket', 'box', 'newspaper', 'coffe_maker', 'tray', 'doorjamb', 'mouse', 'conditioner', 'bag', 'napkin', 'table', 'light', 'soap'] Task:Pet cat response: { thoughts : I walk to my cat, and I pet him, actions : ['[WALK] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['water_glass', 'pot', 'food_ice_cream', 'freezer', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'mousepad', 'food_peanut_butter', 'food_orange', 'wall', 'oven', 'powersocket', 'cutting_board', 'water', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'spoon', 'light'] Task:Drink response:

{ I enter the kitchen and grab a waterglass from the cupboard. I open the fridge and grap some water. I pour the water into the cup and drink it. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_ice_cream', 'chair', 'detergent', 'milk', 'knife', 'drawing', 'cpuscreen', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'computer', 'tvstand', 'faucet', 'couch', 'wall', 'photoframe', 'bed', 'water', 'after_shave', 'mouse', 'controller', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : Walk to bathroom. Walk to sink and turn on the water. Grab the soap and wash the hands., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <water>', '[TURNTO] <water>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>'] } Scene_Objects:['spectacles', 'food_salt', 'chair', 'jelly', 'walllamp', 'milk', 'floor', 'bedroom', 'keyboard', 'button', 'plate', 'tvstand', 'shower', 'window', 'dustpan', 'dining_room', 'nightstand', 'oven', 'basket_for_clothes', 'check', 'coffe_maker', 'tray', 'controller', 'clothes_dress', 'food_steak', 'napkin', 'soap', 'clothes_shirt', 'scrabble', 'washing_machine'] Task:Wash clothes response:

{ Walk to Bathroom. Find basket for clothes. Lift clothes dress from basket. Find washing machine. Walk to washing machine. Put clothes in washing machine. Put soap in washing machine. Switch on washing machine. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['measuring_cup', 'chair', 'walllamp', 'food_butter', 'drawing', 'wallshelf', 'floor', 'ceiling', 'character', 'computer', 'mat', 'tvstand', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'oven', 'photoframe', 'bed', 'coffe_maker', 'television', 'food_donut', 'tray', 'curtain', 'doorjamb', 'pencil', 'dresser', 'napkin', 'dirt'] Task:Relax on sofa response: { thoughts : move to living room, locate sofa, move to sofa, sit on sofa, lie on sofa, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>'] } Scene_Objects:['food_ice_cream', 'chair', 'walllamp', 'bathroom', 'orchid', 'knifeblock', 'cpuscreen', 'needle', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'mousepad', 'couch', 'dining_room', 'wall', 'basket_for_clothes', 'light_bulb', 'food_food', 'check', 'toothbrush_holder', 'mouse', 'comb', 'door', 'clothes_scarf', 'table'] Task:Work response:

{ I walk to the home office. I open the door of the office room and sit on the chair and in front of me is my desktop computer, and I switch on the computer. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'toilet', 'orchid', 'drawing', 'ceiling', 'bedroom', 'computer', 'mat', 'shoe-shine_kit', 'stereo', 'ceilinglamp', 'window', 'tvstand', 'food_orange', 'nightstand', 'bench', 'bed', 'coffe_maker', 'food_food', 'television', 'doorjamb', 'mouse', 'pencil', 'dresser', 'pajamas', 'cupboard', 'bathtub', 'table', 'clothes_shirt', 'coffee'] Task:Listen to music response: { thoughts : I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading., actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['microwave', 'chair', 'freezer', 'ground_coffee', 'walllamp', 'trashcan', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'food_bacon', 'toaster', 'tvstand', 'window', 'oil', 'couch', 'wall', 'nightstand', 'newspaper', 'coffe_maker', 'television', 'coffee_filter', 'water', 'food_donut', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'dishwasher', 'dirt'] Task:Make coffee response:

{ Walk to Kitchen and find coffee maker, find coffee filter and place it in coffee maker. Find ground coffee and water. put both in coffee maker. Close the coffee maker and switch it on. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'bookmark', 'toaster', 'mat', 'tvstand', 'faucet', 'shower', 'laptop', 'mousepad', 'wall', 'oven', 'powersocket', 'towel_rack', 'kitchen_counter', 'headset', 'door', 'sink', 'bathtub', 'home_office', 'bathroom_cabinet', 'light'] Task:Go to toilet response: { thoughts : I go to the bathroom. I locate the toilet. I walk to the toilet., actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[WALK] <toilet>'] } Scene_Objects:['filing_cabinet', 'scissors', 'toilet', 'chair', 'trashcan', 'drawing', 'food_egg', 'floor', 'ceiling', 'bookshelf', 'mat', 'ceilinglamp', 'shower', 'food_jam', 'dining_room', 'broom', 'wall', 'bench', 'photoframe', 'curtain', 'food_onion', 'doorjamb', 'dresser', 'hairbrush', 'cupboard', 'door', 'food_steak', 'light', 'table', 'teeth'] Task:Take shower response:

{ Walk to the bathroom and wash with the shower. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'freezer', 'ground_coffee', 'walllamp', 'food_egg', 'floor', 'ceiling', 'character', 'bedroom', 'bookshelf', 'stovefan', 'plate', 'mousepad', 'wall', 'nightstand', 'powersocket', 'novel', 'coffe_maker', 'check', 'coffee_filter', 'water', 'wooden_spoon', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'dishwasher', 'soap', 'teeth', 'shoe_rack'] Task:Make coffee response: { thoughts : Walk to kitchen, open coffee maker, find coffee filter, grab coffee filter, put coffee filter in coffee maker, find ground coffee, put ground coffee in coffee maker, pour water in coffee maker, close coffee maker and switch on coffee maker., actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>'] } Scene_Objects:['spectacles', 'pot', 'scissors', 'microwave', 'jelly', 'trashcan', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'shampoo', 'ceiling', 'keyboard', 'mail', 'brush', 'toaster', 'stovefan', 'plate', 'picture', 'oil', 'form', 'bowl', 'photoframe', 'newspaper', 'bed', 'kitchen_counter', 'shoes', 'dishrack', 'cupboard', 'home_office'] Task:Read book response:

{ Walk to living room. Find book. Grab book. Open book. Read book. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_salt', 'toilet', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'floor', 'tea_bag', 'bookshelf', 'food_bacon', 'toaster', 'plate', 'tvstand', 'dish_soap', 'mousepad', 'couch', 'wall', 'oven', 'powersocket', 'photoframe', 'coffe_maker', 'food_food', 'toothbrush_holder', 'ice', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'clothes_dress', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : Go to kitchen to put dirty dishs into dishwasher with soap to clean the dirty dishes, actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['glue', 'mop', 'microwave', 'trashcan', 'bills', 'orchid', 'knifeblock', 'drawing', 'hanger', 'floor', 'phone', 'tvstand', 'form', 'pillow', 'bench', 'powersocket', 'light_bulb', 'video_game_controller', 'water', 'centerpiece', 'doorjamb', 'mouse', 'pencil', 'cd', 'door', 'napkin', 'dishwasher', 'soap', 'hands_both', 'creditcard'] Task:Wash hands response:

{ walk to bathroom, look at the water, wash hands }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'glue', 'filing_cabinet', 'microwave', 'jelly', 'freezer', 'ceilingfan', 'orchid', 'food_egg', 'floor', 'phone', 'ceiling', 'desk', 'thread', 'mat', 'laptop', 'deck_of_cards', 'faucet', 'foundation', 'pillow', 'nightstand', 'powersocket', 'basket_for_clothes', 'food_food', 'lighter', 'sink', 'home_office', 'vase', 'soap', 'washing_machine'] Task:Wash clothes response: { thoughts : I go to the bedroom to find and grab basket of clothes. I then go to the bathroom and find the washing machine. I put clothes inside the washing machine and put washing powder. I switch on the washing machine., actions : ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[FIND] <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['filing_cabinet', 'food_bread', 'bathroom', 'hanger', 'floor', 'bookshelf', 'table_cloth', 'stereo', 'window', 'electric_shaver', 'mousepad', 'couch', 'food_orange', 'oven', 'photoframe', 'newspaper', 'bed', 'doorjamb', 'kettle', 'cards', 'hairbrush', 'dresser', 'food_steak', 'clothes_scarf', 'napkin', 'home_office', 'table', 'clothes_skirt', 'scrabble', 'teeth'] Task:Change TV channel response:

{ I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'microwave', 'ground_coffee', 'food_carrot', 'drawing', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'toaster', 'plate', 'faucet', 'foundation', 'mousepad', 'food_jam', 'food_kiwi', 'wall', 'pasta', 'powersocket', 'food_food', 'coffe_maker', 'rag', 'shaving_cream', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'sink', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : Take a dish and put it in the dishwasher to be washed, actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['sheets', 'pot', 'microwave', 'walllamp', 'food_carrot', 'character', 'desk', 'keyboard', 'shower', 'washing_machine', 'window', 'mousepad', 'clothes_pants', 'towel', 'wall', 'powersocket', 'basket_for_clothes', 'check', 'mouthwash', 'food_rice', 'headset', 'chessboard', 'hair', 'napkin', 'table', 'soap', 'scrabble', 'dirt', 'coffee', 'creditcard'] Task:Wash clothes response:

{ walk to the bathroom, grab the basket for clothes, find soap, put in washing machine, turn on }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'trashcan', 'toothbrush', 'bathroom_counter', 'shampoo', 'floor', 'phone', 'character', 'desk', 'bookshelf', 'keyboard', 'toaster', 'ceilinglamp', 'iron', 'shower', 'stereo', 'pillow', 'wall', 'wall_clock', 'photoframe', 'food_food', 'water', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'home_office', 'bathroom_cabinet', 'tooth_paste', 'teeth'] Task:Wash teeth response: { thoughts : Walk to bathroom. Find tooth paste, tooth brush and water. Squeeze tooth paste on tooth brush. Wash teeth., actions : ['[WALK] <bathroom>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[FIND] <toothbrush>', '[FIND] <water>', '[SQUEEZE] <tooth_paste>', '[FIND] <teeth>', '[WASH] <teeth>'] } Scene_Objects:['filing_cabinet', 'food_salt', 'microwave', 'ground_coffee', 'walllamp', 'detergent', 'trashcan', 'food_butter', 'drawing', 'knifeblock', 'floor', 'ceiling', 'toaster', 'mat', 'food_jam', 'pillow', 'wall', 'oven', 'bench', 'cup', 'newspaper', 'coffe_maker', 'coffee_filter', 'water', 'tray', 'food_onion', 'kitchen_counter', 'cupboard', 'home_office', 'dishwasher'] Task:Make coffee response:

{ I walk into the kitchen. I find the coffee maker and open it. I find the coffee filter, grab it and put it into the coffee maker. I find ground coffee, grab it and put it into the coffee maker. I find some water, then I pour it into the coffee maker. I close the coffee maker, I plug it in and I switch it on. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'oil', 'wall', 'nightstand', 'photoframe', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'clothes_dress', 'door', 'light'] Task:Browse internet response: { thoughts : I want to surf the internet and look around at funny pictures., actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <keyboard>', '[GRAB] <keyboard>', '[FIND] <desk>', '[OPEN] <desk>', '[PUTBACK] <keyboard> <desk>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <mousepad>', '[PUTBACK] <mouse> <mousepad>', '[PLUGIN] <keyboard>', '[PLUGIN] <mouse>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[GRAB] <mouse>', '[TOUCH] <mouse>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['food_pizza', 'tablelamp', 'microwave', 'chair', 'bathroom', 'orchid', 'drawing', 'food_egg', 'knife', 'floor', 'computer', 'tvstand', 'window', 'couch', 'candle', 'microphone', 'pillow', 'towel', 'wall', 'food_food', 'check', 'television', 'wooden_spoon', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'napkin', 'table', 'coffee'] Task:Set up table response:

{ walk to entrance hall. find a table. pull table. walk to living rook. push table. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['juice', 'crayon', 'walllamp', 'trashcan', 'dough', 'floor', 'phone', 'bedroom', 'tea_bag', 'toaster', 'mat', 'plate', 'ceilinglamp', 'dish_soap', 'wall', 'pasta', 'oven', 'cutting_board', 'food_cheese', 'newspaper', 'coffe_maker', 'check', 'food_food', 'tray', 'towel_rack', 'pencil', 'dresser', 'conditioner', 'home_office', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : I walk to the kitchen. I search and find dishwasher. I search dishes. I put dishes inside the dishwasher. I put dish soap in dishwasher. I switch on dishwasher and wait for dishes to be washed., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['dry_pasta', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'milk', 'floor', 'ceiling', 'desk', 'keyboard', 'button', 'mop_bucket', 'toaster', 'stereo', 'window', 'wall', 'powersocket', 'bench', 'newspaper', 'coffe_maker', 'tray', 'curtain', 'food_sugar', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'coffee_cup', 'dishwasher', 'light', 'clothes_shirt'] Task:Make coffee response:

{ walk to kitchen, look at the coffee maker, open the coffee maker, find milk, suger and water, mix that all, put into coffee maker, switch on the coffee maker, wait for few mins, push the coffee button in coffee maker, we get coffee in coffee cup, drink coffee }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_salt', 'microwave', 'detergent', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'shoe-shine_kit', 'faucet', 'clothes_socks', 'closetdrawer', 'mousepad', 'dining_room', 'broom', 'wall', 'nightstand', 'photoframe', 'television', 'water', 'tray', 'cards', 'paper_towel', 'door', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : I walk into the bathroom. I turn on the water. I put soap on my hands. I rinse my hands. I turn off the water. I dry my hands., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <water>', '[TURNTO] <water>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[TURNTO] <water>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>'] } Scene_Objects:['pot', 'food_ice_cream', 'mop', 'tea', 'freezer', 'walllamp', 'floor', 'character', 'stovefan', 'toaster', 'mat', 'tvstand', 'stereo', 'window', 'electric_shaver', 'food_noodles', 'couch', 'soap', 'pillow', 'wall', 'bench', 'toilet_paper', 'food_food', 'doorjamb', 'diary', 'dresser', 'hairbrush', 'napkin', 'bathroom_cabinet', 'colander'] Task:Go to toilet response:

{ I walk to bathroom. find closet. Uset It. Clean it. Use Toilet paper }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'bathroom', 'food_carrot', 'wallshelf', 'ceiling', 'dvd_player', 'character', 'bedroom', 'desk', 'keyboard', 'thread', 'stovefan', 'shower', 'faucet', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'cup', 'bed', 'food_food', 'razor', 'toothbrush_holder', 'curtain', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'napkin', 'table', 'clothes_skirt'] Task:Pick up phone response: { thoughts : Go to the living room. Find the telephone. Lift up the receiver., actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>'] } Scene_Objects:['sponge', 'spectacles', 'microwave', 'walllamp', 'drawing', 'orchid', 'hanger', 'floor', 'character', 'desk', 'alcohol', 'stovefan', 'ceilinglamp', 'mat', 'window', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'cutting_board', 'photoframe', 'light_bulb', 'television', 'curtain', 'kettle', 'napkin', 'bathroom_cabinet', 'table', 'creditcard'] Task:Relax on sofa response:

{ walk to living room, walk to sofa, sit on sofa. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'dvd_player', 'desk', 'keyboard', 'purse', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'food_noodles', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'table'] Task:Write an email response: { thoughts : FIRST YOU NEED TO SWITVH ON YOU COMPUTER AND CHECK THE INTERNET CONNECTION.FOR SENDING EMAIL EMAIL ID FOR REQUIRED FOR BOTH SEND AND RECEIVE .SO CLEALY MENTION THE ID ON THE TO PLACE THEN ONLY IT WILL GO CORRECTLY, actions : ['[WALK] <home_office>', '[WALK] <table>', '[FIND] <table>', '[FIND] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['tablelamp', 'microwave', 'walllamp', 'detergent', 'trashcan', 'floor', 'ceiling', 'bedroom', 'toaster', 'mat', 'stereo', 'pillow', 'wall', 'cup', 'bed', 'coffe_maker', 'food_food', 'coffee_filter', 'water', 'food_donut', 'wooden_spoon', 'food_onion', 'doorjamb', 'pencil', 'kitchen_counter', 'cupboard', 'napkin', 'spoon', 'dishwasher', 'coffee'] Task:Make coffee response:

{ I find the coffee machine, fill it with water and coffee then press the button to make the coffee }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'tablelamp', 'juice', 'nail_polish', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'bedroom', 'mat', 'shower', 'window', 'closetdrawer', 'wall', 'nightstand', 'cutting_board', 'bed', 'photoframe', 'coffe_maker', 'television', 'curtain', 'mouse', 'pencil', 'vacuum_cleaner', 'hair', 'maindoor', 'table', 'vase'] Task:Read book response: { thoughts : I lie on my bed and read a book., actions : ['[WALK] <bedroom>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <bed>', '[LIE] <bed>', '[READ] <novel>'] } Scene_Objects:['tablelamp', 'microwave', 'walllamp', 'drawing', 'orchid', 'floor', 'folder', 'mop_bucket', 'ceilinglamp', 'stereo', 'picture', 'window', 'mousepad', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'nightstand', 'bench', 'powersocket', 'novel', 'coffe_maker', 'toilet_paper', 'toothbrush_holder', 'tray', 'curtain', 'lighter', 'headset', 'cupboard', 'table'] Task:Relax on sofa response:

{ I walk to the living room and find the sofa. I sit on the sofa and get comfortable. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'toilet', 'freezer', 'walllamp', 'drawing', 'hanger', 'floor', 'mat', 'tvstand', 'window', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'cutting_board', 'cup', 'novel', 'food_food', 'television', 'wine', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'shoes', 'bathtub', 'bathroom_cabinet', 'table', 'soap', 'board_game'] Task:Relax on sofa response: { thoughts : lie in the sofa, relax, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[LIE] <couch>'] } Scene_Objects:['sponge', 'walllamp', 'ground_coffee', 'trashcan', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'foundation', 'couch', 'microphone', 'wall', 'powersocket', 'oven', 'bed', 'television', 'wooden_spoon', 'doorjamb', 'lighter', 'dresser', 'door', 'table'] Task:Change TV channel response:

{ I go to the living room where the TV is located. I plug in the TV to the outlet. I search for the remote control. I point the remote control directly to the TV, turn it on and push the number of the channel that I want. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'microwave', 'chair', 'freezer', 'walllamp', 'detergent', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'stereo', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'television', 'curtain', 'doorjamb', 'mouse', 'dresser', 'door', 'bag', 'light', 'table'] Task:Turn on computer response: { thoughts : Press the power button on the computer to turn it on, actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['scissors', 'food_ice_cream', 'chair', 'bathroom', 'trashcan', 'food_carrot', 'shampoo', 'phone', 'floor', 'stamp', 'bookshelf', 'ceilinglamp', 'window', 'homework', 'couch', 'clothes_pants', 'pillow', 'nightstand', 'cup', 'bed', 'check', 'food_food', 'ice', 'headset', 'cupboard', 'door', 'home_office', 'light', 'dishwasher', 'clothes_shirt'] Task:Pick up phone response:

{ walk to phone, grab phone, pick up phone, put to ear }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['water_glass', 'filing_cabinet', 'food_salt', 'microwave', 'blow_dryer', 'detergent', 'knife', 'orchid', 'bathroom_counter', 'shampoo', 'keyboard', 'bookshelf', 'mail', 'stovefan', 'ceilinglamp', 'toaster', 'mat', 'faucet', 'food_peanut_butter', 'dining_room', 'nightstand', 'oven', 'cup', 'light_bulb', 'food_food', 'television', 'food_onion', 'pencil', 'napkin', 'light'] Task:Drink response: { thoughts : Walk to kitchen. Find water glass. Grab water glass. Find water. Pour water in water glass. Drink water from water glass., actions : ['[WALK] <dining_room>', '[WALK] <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>'] } Scene_Objects:['spectacles', 'pot', 'filing_cabinet', 'scissors', 'toilet', 'freezer', 'ground_coffee', 'detergent', 'food_egg', 'cpuscreen', 'phone', 'folder', 'character', 'keyboard', 'envelope', 'piano_bench', 'ceilinglamp', 'plate', 'faucet', 'couch', 'coffe_maker', 'food_donut', 'tray', 'centerpiece', 'doorjamb', 'mouse', 'dishrack', 'dresser', 'bathroom_cabinet', 'light'] Task:Pick up phone response:

{ I walk to the home office, find where the phone is and lift the reciever. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['blender', 'chair', 'walllamp', 'dough', 'orchid', 'cpuscreen', 'hanger', 'floor', 'keyboard', 'remote_control', 'food_cake', 'envelope', 'computer', 'button', 'food_bacon', 'ceilinglamp', 'stereo', 'homework', 'oven', 'tape', 'photoframe', 'coffee_table', 'keys', 'check', 'novel', 'light_bulb', 'wooden_spoon', 'curtain', 'cd', 'home_office'] Task:Change TV channel response: { thoughts : walk next to the coffee table. pick up the remote control from the top of the coffee table. Point the remote to the TV. Press the blue arrow on the remote., actions : ['[WALK] <home_office>', '[WALK] <coffee_table>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>'] } Scene_Objects:['pot', 'filing_cabinet', 'food_bread', 'microwave', 'freezer', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'couch', 'clothes_hat', 'pillow', 'wall', 'nightstand', 'powersocket', 'box', 'oven_mitts', 'food_onion', 'doorjamb', 'kitchen_counter', 'chessboard', 'dresser', 'cupboard', 'door', 'light', 'soap'] Task:Turn on light response:

{ Turning on lights }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'filing_cabinet', 'food_pizza', 'food_salt', 'jelly', 'band-aids', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'broom', 'wall', 'powersocket', 'doorjamb', 'lighter', 'door', 'sink', 'light', 'table', 'laser_pointer', 'clothes_shirt', 'creditcard'] Task:Turn on light response: { thoughts : I go into my room, find the light, then turn on the lights., actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[WALK] <light>', '[SWITCHON] <light>'] } Scene_Objects:['pot', 'walllamp', 'trashcan', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bedroom', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'foundation', 'dustpan', 'pillow', 'broom', 'wall', 'powersocket', 'cup', 'video_game_controller', 'television', 'doorjamb', 'hairbrush', 'door', 'sink', 'bag', 'table'] Task:Watch TV response:

{ Walk to living room. Find remote control. Find television. Point remote at television. Press \ on\ button. Watch. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['glue', 'food_pizza', 'filing_cabinet', 'toilet', 'walllamp', 'detergent', 'orchid', 'food_egg', 'floor', 'phone', 'ceiling', 'character', 'keyboard', 'alcohol', 'toaster', 'tvstand', 'faucet', 'balanceball', 'picture', 'wall', 'oven', 'tape', 'food_cheese', 'photoframe', 'newspaper', 'coffe_maker', 'tray', 'towel_rack', 'table', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : Walk to the sink. Take dishes out of sink. Open dishwasher and place dishes in dishwasher., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['tea', 'walllamp', 'drawing', 'orchid', 'food_egg', 'floor', 'ceiling', 'phone', 'character', 'remote_control', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'shower', 'couch', 'clothes_hat', 'wall', 'powersocket', 'basket_for_clothes', 'check', 'mouthwash', 'television', 'food_onion', 'doorjamb', 'controller', 'door', 'table'] Task:Change TV channel response:

{ Walk to TV, grab remote control, press change channel button, repeat pressing change channel button util find the channel wanted, put back remote control }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'filing_cabinet', 'freezer', 'blow_dryer', 'bathroom', 'detergent', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'toaster', 'faucet', 'stereo', 'couch', 'pillow', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'bed', 'photoframe', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'napkin', 'table', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : Washing Hands, actions : ['[WALK] <dining_room>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[TOUCH] <soap>', '[PUTOBJBACK] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>'] } Scene_Objects:['pot', 'microwave', 'band-aids', 'walllamp', 'drawing', 'bills', 'orchid', 'floor', 'ceiling', 'character', 'computer', 'bookmark', 'brush', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'plate', 'oil', 'mousepad', 'wall', 'powersocket', 'oven', 'television', 'toothbrush_holder', 'doorjamb', 'door', 'napkin', 'table', 'teeth'] Task:Watch TV response:

{ Watch TV in the living room. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'water_glass', 'pot', 'glue', 'walllamp', 'trashcan', 'knifeblock', 'ceiling', 'clothes_jacket', 'stovefan', 'toaster', 'mat', 'faucet', 'microphone', 'wall', 'cup', 'bed', 'food_food', 'check', 'water', 'food_donut', 'curtain', 'kitchen_counter', 'chessboard', 'cupboard', 'laundry_detergent', 'sink', 'spoon', 'bathroom_cabinet', 'dirt'] Task:Drink response: { thoughts : I walk to the kitchen. open the cupboard. Find the water glass, grab it. Fill the glass with water and drink water., actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>'] } Scene_Objects:['food_salt', 'microwave', 'cat', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'bedroom', 'table_cloth', 'mat', 'plate', 'stereo', 'ceilinglamp', 'tvstand', 'electric_shaver', 'microphone', 'wall', 'powersocket', 'light_bulb', 'keys', 'doorjamb', 'pencil', 'laundry_detergent', 'door', 'clothes_scarf', 'sink', 'spoon', 'light'] Task:Turn on light response:

{ I open the room door and press the light button on }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_bread', 'drawing', 'orchid', 'knifeblock', 'bills', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'shower', 'stereo', 'mousepad', 'couch', 'pillow', 'wall', 'oven', 'photoframe', 'television', 'food_rice', 'tray', 'curtain', 'doorjamb', 'pencil', 'kitchen_counter', 'door', 'home_office', 'table', 'light', 'bathroom_cabinet'] Task:Relax on sofa response: { thoughts : Walk into the living room. Walk up to the sofa. Sit down on the sofa., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>'] } Scene_Objects:['pot', 'jelly', 'chair', 'freezer', 'bathroom', 'food_carrot', 'knifeblock', 'bathroom_counter', 'keyboard', 'alcohol', 'clothes_jacket', 'stovefan', 'mat', 'toaster', 'stereo', 'picture', 'ceilinglamp', 'dining_room', 'bowl', 'wall', 'oven', 'powersocket', 'cup', 'photoframe', 'check', 'video_game_controller', 'razor', 'food_food', 'curtain', 'shoes'] Task:Listen to music response:

{ turn radio on, listen to music }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['measuring_cup', 'microwave', 'cat', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'character', 'desk', 'mat', 'deck_of_cards', 'iron', 'stereo', 'balanceball', 'shower', 'faucet', 'mousepad', 'nightstand', 'oven', 'television', 'tray', 'curtain', 'mouse', 'pencil', 'kitchen_counter', 'dresser', 'cupboard', 'clothes_dress', 'sink', 'vase'] Task:Walk through response: { thoughts : Walk through the hallway., actions : ['[WALK] <home_office>', '[WALK] <home_office>'] } Scene_Objects:['scissors', 'chair', 'freezer', 'floor', 'phone', 'character', 'thread', 'ceilinglamp', 'stereo', 'shower', 'window', 'mousepad', 'pillow', 'broom', 'wall', 'cup', 'photoframe', 'clothes_gloves', 'food_food', 'coffe_maker', 'razor', 'lighter', 'doorjamb', 'shoes', 'hairbrush', 'napkin', 'bathroom_cabinet', 'table', 'laser_pointer', 'clothes_shirt'] Task:Listen to music response:

{ Find the radio; switch on the radio and listen to music. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'food_bread', 'microwave', 'chair', 'band-aids', 'woman', 'needle', 'longboard', 'man', 'keyboard', 'envelope', 'toaster', 'mat', 'ceilinglamp', 'shower', 'faucet', 'stereo', 'nightstand', 'box', 'light_bulb', 'coffe_maker', 'curtain', 'towel_rack', 'shoes', 'dresser', 'hairbrush', 'door', 'vase', 'instrument_violin', 'creditcard'] Task:Greet guests response: { thoughts : Answer the door. Smile and give a warm hello, or other appropriate greeting. With newcomers to your home, offer your hand to be shook. With old friends it is appropriate to hug, or kiss one another on the cheek., actions : ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>'] } Scene_Objects:['filing_cabinet', 'dog', 'walllamp', 'bathroom', 'drawing', 'knifeblock', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'computer', 'bookmark', 'ceilinglamp', 'tvstand', 'shower', 'window', 'foundation', 'couch', 'pillow', 'wall', 'razor', 'toothbrush_holder', 'tray', 'curtain', 'mouse', 'clothes_dress', 'sink', 'bathroom_cabinet', 'table'] Task:Relax on sofa response:

{ allow sofa to support weight in order to decrease gravity induced entropy }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'blender', 'crayon', 'walllamp', 'cat', 'drawing', 'orchid', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'bookmark', 'ceilinglamp', 'plate', 'window', 'couch', 'pillow', 'wall', 'oven', 'cup', 'bed', 'clothes_gloves', 'newspaper', 'coffe_maker', 'curtain', 'hairbrush', 'food_steak', 'bag', 'table'] Task:Relax on sofa response: { thoughts : walk to living room, find sofa, sit in sofa, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>'] } Scene_Objects:['jelly', 'trashcan', 'cpuscreen', 'clothes_underwear', 'ceiling', 'folder', 'desk', 'computer', 'stovefan', 'shower', 'mousepad', 'candle', 'clothes_hat', 'dining_room', 'newspaper', 'photoframe', 'food_food', 'video_game_controller', 'oven_mitts', 'curtain', 'pencil', 'kitchen_counter', 'dishrack', 'laundry_detergent', 'door', 'light', 'dishwasher', 'soap', 'tooth_paste', 'washing_machine'] Task:Wash clothes response:

{ Walk to bathroom. Open washer. Put clothes in washer. Put soap in washer. Close washer. Turn washer on. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'mop', 'toilet', 'freezer', 'walllamp', 'bathroom', 'cat', 'food_butter', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'computer', 'mat', 'tvstand', 'iron', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'toy', 'tape', 'photoframe', 'television', 'food_rice', 'doorjamb', 'cards', 'door'] Task:Relax on sofa response: { thoughts : walk into living room, look at the sofa which one is available, sit on the sofa, now take relax on the sofa, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>'] } Scene_Objects:['pot', 'chair', 'walllamp', 'ground_coffee', 'detergent', 'trashcan', 'orchid', 'drawing', 'bedroom', 'tea_bag', 'bookshelf', 'envelope', 'alcohol', 'computer', 'ceilinglamp', 'mat', 'shower', 'deck_of_cards', 'food_noodles', 'microphone', 'bowl', 'wall', 'bench', 'powersocket', 'photoframe', 'television', 'dresser', 'napkin', 'table', 'clothes_shirt'] Task:Pet cat response:

{ First I need to find the cat in the living room. Then I walk over to the cat and pet it gently. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'food_ice_cream', 'chair', 'nail_polish', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'button', 'ceilinglamp', 'balanceball', 'shower', 'mousepad', 'pillow', 'wall', 'nightstand', 'basket_for_clothes', 'toothbrush_holder', 'doorjamb', 'mouse', 'light', 'vase'] Task:Browse internet response: { thoughts : Walk to the Home Office. Find the computer. Turn on the computer., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['food_salt', 'beer', 'microwave', 'chair', 'drawing', 'hanger', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'clothes_jacket', 'bookmark', 'laptop', 'ceilinglamp', 'faucet', 'shower', 'mousepad', 'couch', 'food_peanut_butter', 'photoframe', 'newspaper', 'razor', 'tray', 'kitchen_counter', 'vacuum_cleaner', 'clothes_dress', 'door', 'bathroom_cabinet', 'tooth_paste'] Task:Write an email response:

{ I go to my bed room and sit on the chair and in front of me is my desktop computer and start writing an email. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_pizza', 'filing_cabinet', 'nail_polish', 'toothbrush', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'food_food', 'toothbrush_holder', 'tray', 'dresser', 'cupboard', 'controller', 'door', 'sink', 'bathroom_cabinet', 'home_office', 'light', 'tooth_paste'] Task:Wash teeth response: { thoughts : I go into the bathroom, go to the sink, get toothbrush and toothpaste. Put toothpaste on the toothbrush, brush teeth, turn on faucet, rinse brush, and return toothbrush., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <toothbrush_holder>', '[TURNTO] <toothbrush_holder>', '[LOOKAT] <toothbrush_holder>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[PUTBACK] <tooth_paste> <toothbrush_holder>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <toothbrush>', '[PUTBACK] <toothbrush> <toothbrush_holder>'] } Scene_Objects:['dry_pasta', 'pot', 'filing_cabinet', 'tablelamp', 'toilet', 'walllamp', 'trashcan', 'drawing', 'orchid', 'bills', 'floor', 'ceiling', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'plate', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'cup', 'photoframe', 'television', 'curtain', 'doorjamb', 'console', 'door', 'table'] Task:Watch TV response:

{ go to living room, sit on couch, get remote, switch on tv, watch tv }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'walllamp', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'oven', 'cutting_board', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'dresser', 'food_steak', 'sink', 'bathroom_cabinet', 'table'] Task:Browse internet response: { thoughts : I sit at my computer desk and open the browser., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['pot', 'microwave', 'freezer', 'bathroom', 'trashcan', 'dough', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'food_cake', 'computer', 'toaster', 'ceilinglamp', 'mat', 'deck_of_cards', 'mousepad', 'clothes_socks', 'pillow', 'wall', 'powersocket', 'bench', 'oven', 'food_food', 'doorjamb', 'mouse', 'door', 'light'] Task:Put groceries in Fridge response:

{ Open the fridge, and put groceries in the fridge. Close the fridge. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['juice', 'food_salt', 'walllamp', 'detergent', 'trashcan', 'knifeblock', 'drawing', 'floor', 'stamp', 'table_cloth', 'plate', 'faucet', 'deck_of_cards', 'clothes_pants', 'wall', 'bench', 'powersocket', 'tape', 'photoframe', 'food_food', 'tray', 'pencil', 'kitchen_counter', 'cupboard', 'maindoor', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'coffee'] Task:Bring dirty plate to sink response: { thoughts : Stand up from the table. Pick up dirty plate. Walk to sink. Put plate in sink., actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[TURNTO] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sink>', '[PUTBACK] <plate> <sink>'] } Scene_Objects:['sheets', 'freezer', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'shower', 'stereo', 'mousepad', 'wall', 'powersocket', 'food_food', 'food_donut', 'tray', 'after_shave', 'doorjamb', 'cards', 'mouse', 'shoes', 'dresser', 'food_steak', 'door', 'bathroom_cabinet', 'light', 'clothes_skirt'] Task:Cook some food response:

{ Go kitchen and make something for eat }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'freezer', 'cat', 'orchid', 'drawing', 'hanger', 'ceiling', 'dvd_player', 'desk', 'mail', 'piano_bench', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'mousepad', 'food_orange', 'pillow', 'bench', 'bed', 'check', 'doorjamb', 'cd', 'controller', 'laundry_detergent', 'sink', 'home_office', 'dishwasher'] Task:Pet cat response: { thoughts : I go to the living room then go to the cat and touch it., actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['measuring_cup', 'walllamp', 'bathroom', 'drawing', 'orchid', 'hanger', 'floor', 'phone', 'character', 'stamp', 'tea_bag', 'toaster', 'ceilinglamp', 'shoe-shine_kit', 'iron', 'brush', 'window', 'couch', 'food_orange', 'pillow', 'wall', 'bench', 'tray', 'curtain', 'after_shave', 'sink', 'bathroom_cabinet', 'table', 'home_office', 'soap'] Task:Relax on sofa response:

{ Sitting down and relaxing on the sofa }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'toilet', 'chair', 'walllamp', 'trashcan', 'drawing', 'hanger', 'floor', 'ceiling', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'laptop', 'foundation', 'oil', 'couch', 'pillow', 'wall', 'wall_clock', 'cup', 'novel', 'television', 'curtain', 'after_shave', 'door', 'napkin', 'home_office', 'table'] Task:Turn off TV response: { thoughts : Walk over to tv and press power button, actions : ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHOFF] <television>'] } Scene_Objects:['spectacles', 'blender', 'food_salt', 'jelly', 'freezer', 'orchid', 'drawing', 'clothes_underwear', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'tea_bag', 'bookshelf', 'toaster', 'tvstand', 'shower', 'mousepad', 'clothes_pants', 'wall', 'powersocket', 'bed', 'food_food', 'tray', 'doorjamb', 'cards', 'controller', 'door', 'light', 'dishwasher'] Task:Turn on light response:

{ I enter the bedroom and find the light. Then I turn it on. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'pot', 'tablelamp', 'microwave', 'detergent', 'clothes_underwear', 'ceiling', 'character', 'desk', 'mail', 'table_cloth', 'bookmark', 'shoe-shine_kit', 'faucet', 'electric_shaver', 'mousepad', 'candle', 'food_jam', 'food_orange', 'nightstand', 'powersocket', 'newspaper', 'coin', 'food_onion', 'pencil', 'dresser', 'home_office', 'dishwasher', 'tooth_paste', 'coffee'] Task:Browse internet response: { thoughts : The task is browse and surf on the internet regarding a particular topic, actions : ['[WALK] <bedroom>', '[WALK] <laptop>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[WATCH] <laptop>'] } Scene_Objects:['pot', 'tablelamp', 'freezer', 'bathroom', 'detergent', 'food_butter', 'drawing', 'hanger', 'phone', 'bedroom', 'desk', 'toaster', 'brush', 'stereo', 'faucet', 'window', 'couch', 'pillow', 'dining_room', 'nightstand', 'powersocket', 'cup', 'coffe_maker', 'mouthwash', 'television', 'curtain', 'doorjamb', 'mouse', 'napkin', 'teeth'] Task:Listen to music response:

{ Listen to music }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'cat', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'food_bacon', 'stovefan', 'ceilinglamp', 'brush', 'faucet', 'stereo', 'tvstand', 'towel', 'pillow', 'wall', 'pasta', 'powersocket', 'coffe_maker', 'oven_mitts', 'tray', 'curtain', 'dresser', 'cupboard', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : I go into the bathroom, get my hands wet, add soap, suds up my hands, rinse the soap off, turn the faucet off, dry my hands., actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <soap>', '[PUTOBJBACK] <soap>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>'] } Scene_Objects:['filing_cabinet', 'food_ice_cream', 'bathroom', 'food_carrot', 'knifeblock', 'hanger', 'bookshelf', 'computer', 'button', 'stovefan', 'couch', 'candle', 'dining_room', 'wall', 'bench', 'basket_for_clothes', 'newspaper', 'light_bulb', 'check', 'coffe_maker', 'television', 'after_shave', 'curtain', 'comb', 'pajamas', 'hair', 'door', 'sink', 'dishwasher', 'colander'] Task:Pet cat response:

{ Walk to living room. Find the cat. Walk over to the cat. Touch the cat. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'beer', 'microwave', 'chair', 'freezer', 'ground_coffee', 'floor', 'ceiling', 'mail', 'food_bacon', 'toaster', 'deck_of_cards', 'faucet', 'window', 'wall', 'wall_clock', 'bench', 'cutting_board', 'toy', 'light_bulb', 'coffe_maker', 'coffee_filter', 'water', 'curtain', 'after_shave', 'pencil', 'kitchen_counter', 'pajamas', 'sink', 'light'] Task:Make coffee response: { thoughts : Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker., actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[FIND] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>'] } Scene_Objects:['filing_cabinet', 'chair', 'freezer', 'dog', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'envelope', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'wall', 'pasta', 'nightstand', 'bench', 'photoframe', 'tray', 'mouse', 'door', 'table', 'soap'] Task:Work response:

{ go to home office. turn the computer on. begin working }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'check', 'television', 'curtain', 'doorjamb', 'door', 'home_office', 'table', 'light'] Task:Watch TV response: { thoughts : Go to the living room. Find the remote. Pick up the remote. Find the sofa. Sit on the sofa. Look at the television. Aim the remote at the television. Press the power button. Flip the channels., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[PUSH] <remote_control>', '[WATCH] <television>'] } Scene_Objects:['pot', 'tablelamp', 'blender', 'crayon', 'walllamp', 'cat', 'drawing', 'orchid', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'bookmark', 'ceilinglamp', 'plate', 'window', 'couch', 'pillow', 'wall', 'oven', 'cup', 'bed', 'clothes_gloves', 'newspaper', 'coffe_maker', 'curtain', 'hairbrush', 'food_steak', 'bag', 'table'] Task:Relax on sofa response:

{ walk to living room, find sofa, sit in sofa }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'mop', 'chair', 'band-aids', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'laptop', 'toaster', 'foundation', 'pillow', 'wall', 'powersocket', 'bench', 'novel', 'doorjamb', 'mouse', 'kitchen_counter', 'door', 'napkin', 'light', 'soap', 'instrument_violin'] Task:Turn off light response: { thoughts : Grasp light switch, flip light switch., actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[TURNTO] <light>', '[SWITCHOFF] <light>'] } Scene_Objects:['walllamp', 'dough', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'mat', 'window', 'mousepad', 'food_noodles', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'television', 'tray', 'curtain', 'doorjamb', 'mouse', 'pencil', 'hair', 'door', 'table', 'instrument_violin'] Task:Watch TV response:

{ Go to the living room and sit on the couch. Turn on television using remote control. Use remote control buttons to navigate to desired channel. Watch television. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['glue', 'crayon', 'chair', 'cat', 'dough', 'milk', 'hanger', 'floor', 'keyboard', 'mail', 'table_cloth', 'stovefan', 'plate', 'faucet', 'tvstand', 'window', 'couch', 'form', 'dining_room', 'cutting_board', 'photoframe', 'check', 'wine', 'dresser', 'hairbrush', 'pajamas', 'conditioner', 'home_office', 'bathroom_cabinet', 'table'] Task:Give milk to cat response: { thoughts : Grab milk and pour it into the plate so that the cat can drink, actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[POINTAT] <cat>', '[PULL] <cat>', '[FIND] <milk>', '[GRAB] <milk>', '[FIND] <plate>', '[POUR] <milk> <plate>', '[TOUCH] <cat>', '[SCRUB] <cat>'] } Scene_Objects:['blender', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'basket_for_clothes', 'cup', 'television', 'food_rice', 'curtain', 'doorjamb', 'diary', 'shoes', 'door', 'spoon', 'bathroom_cabinet', 'table'] Task:Watch TV response:

{ I walk into the living room and sit on the sofa to watch tv }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'sponge', 'scissors', 'food_salt', 'trashcan', 'drawing', 'needle', 'hanger', 'longboard', 'floor', 'character', 'stamp', 'keyboard', 'stovefan', 'ceilinglamp', 'deck_of_cards', 'window', 'couch', 'dining_room', 'wall', 'photoframe', 'television', 'curtain', 'rag', 'pencil', 'shoes', 'clothes_dress', 'conditioner', 'sink', 'table'] Task:Text friends while sitting on couch response: { thoughts : Text while sitting, actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[TOUCH] <phone>'] } Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'toaster', 'deck_of_cards', 'window', 'tvstand', 'mousepad', 'pillow', 'wall', 'pasta', 'light_bulb', 'check', 'mouthwash', 'wooden_spoon', 'mouse', 'door', 'table', 'coffee'] Task:Browse internet response:

{ Turn on computer, pull up browser, browse the internet }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'toilet', 'chair', 'freezer', 'band-aids', 'walllamp', 'cat', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'bedroom', 'ceilinglamp', 'tvstand', 'clothes_socks', 'couch', 'pillow', 'dining_room', 'wall', 'bench', 'clothes_gloves', 'novel', 'tray', 'doorjamb', 'kitchen_counter', 'door', 'table', 'light', 'dishwasher'] Task:Pet cat response: { thoughts : walk to entrance hall, look at the sofa, sit on the sofa, look at the cat, allow cat to near with you, touch the cat smoothly on it head, now pet the cat smoothly, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['glue', 'pot', 'tablelamp', 'microwave', 'drawing', 'knife', 'knifeblock', 'hanger', 'bathroom_counter', 'phone', 'stovefan', 'laptop', 'faucet', 'foundation', 'couch', 'food_orange', 'pillow', 'bowl', 'bench', 'oven', 'basket_for_clothes', 'cup', 'novel', 'razor', 'centerpiece', 'doorjamb', 'shaving_cream', 'mouse', 'door', 'soap'] Task:Turn on light response:

{ Walk to the living room, walk to the lamp, switch on the lamp. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'chair', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'keyboard', 'alcohol', 'toaster', 'tvstand', 'shower', 'closetdrawer', 'nightstand', 'wall_clock', 'bench', 'powersocket', 'food_food', 'doorjamb', 'towel_rack', 'mouse', 'cupboard', 'sink', 'home_office', 'table', 'light', 'coffee'] Task:Walk through response: { thoughts : Walk through the hallway., actions : ['[WALK] <home_office>', '[WALK] <dining_room>', '[WALK] <home_office>'] } Scene_Objects:['spectacles', 'sheets', 'sponge', 'chair', 'freezer', 'trashcan', 'ceiling', 'stamp', 'desk', 'keyboard', 'table_cloth', 'stovefan', 'ceilinglamp', 'shower', 'iron', 'electric_shaver', 'mousepad', 'clothes_socks', 'powersocket', 'oven', 'tray', 'kitchen_counter', 'dishrack', 'hair', 'cupboard', 'door', 'hairdryer', 'bathroom_cabinet', 'instrument_guitar', 'coffee'] Task:Listen to music response:

{ walk to living room ,find radio ,switch on radio ,listen to music 4 }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['mop', 'microwave', 'freezer', 'ground_coffee', 'dough', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'bedroom', 'tea_bag', 'toaster', 'faucet', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'bench', 'cutting_board', 'toy', 'coffe_maker', 'television', 'coffee_filter', 'water', 'mouse', 'kitchen_counter', 'sink', 'table'] Task:Make coffee response: { thoughts : Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker., actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>'] } Scene_Objects:['glue', 'food_bread', 'mop', 'freezer', 'trashcan', 'knifeblock', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'stovefan', 'mat', 'faucet', 'pillow', 'wall', 'powersocket', 'bed', 'food_food', 'check', 'mouthwash', 'after_shave', 'doorjamb', 'chessboard', 'dresser', 'cupboard', 'hair', 'door', 'instrument_guitar', 'light', 'creditcard'] Task:Turn on light response:

{ Walk into living room. Find wall. Find light button. Switch on light button. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'picture', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'dresser', 'door', 'light'] Task:Write an email response: { thoughts : I need to write an e-mail to my boss about the meeting at work tomorrow., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <keyboard>', '[GRAB] <keyboard>', '[OPEN] <desk>', '[PUTBACK] <keyboard> <desk>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <mousepad>', '[PUTBACK] <mouse> <mousepad>', '[PLUGIN] <keyboard>', '[PLUGIN] <mouse>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[TYPE] <keyboard>', '[GRAB] <mouse>', '[TOUCH] <mouse>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['microwave', 'toilet', 'knifeblock', 'floor', 'ceiling', 'purse', 'computer', 'table_cloth', 'stovefan', 'mat', 'faucet', 'window', 'bowl', 'wall', 'powersocket', 'cutting_board', 'television', 'razor', 'tray', 'after_shave', 'doorjamb', 'shoes', 'comb', 'dresser', 'door', 'home_office', 'light', 'dishwasher', 'soap', 'coffee'] Task:Turn on light response:

{ I walk in to the living room. I find the light switch. I turn on the lights. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_ice_cream', 'measuring_cup', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'keyboard', 'mail', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'window', 'couch', 'candle', 'pillow', 'bowl', 'wall', 'powersocket', 'television', 'curtain', 'after_shave', 'doorjamb', 'chessboard', 'door', 'food_steak', 'bathroom_cabinet', 'table', 'board_game'] Task:Watch TV response: { thoughts : I walk to the living room. I grab the remote control. I walk to the sofa. I sit down, and press the on button on the remote., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>'] } Scene_Objects:['filing_cabinet', 'walllamp', 'bathroom', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'desk', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'powersocket', 'clothes_gloves', 'television', 'razor', 'curtain', 'doorjamb', 'console', 'mouse', 'door', 'bag', 'table', 'dishwasher'] Task:Change TV channel response:

{ I walk in living room. I find TV remote. I grab TV remote. I sit on sofa. I switch on TV. I switch channel. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'bedroom', 'keyboard', 'tea_bag', 'computer', 'food_bacon', 'tvstand', 'iron', 'window', 'electric_shaver', 'mousepad', 'dining_room', 'wall', 'nightstand', 'wall_clock', 'photoframe', 'towel_rack', 'mouse', 'table'] Task:Check email response: { thoughts : Sit in teak deck chair, have wooden drawing board on lap, laptop on wooden drawing board, log in to my two email accounts, go through new emails and respond., actions : ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[WALK] <chair>', '[SIT] <chair>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>'] } Scene_Objects:['filing_cabinet', 'microwave', 'freezer', 'cpuscreen', 'hanger', 'floor', 'keyboard', 'purse', 'bookshelf', 'food_bacon', 'button', 'toaster', 'laptop', 'stereo', 'couch', 'wall', 'bench', 'basket_for_clothes', 'toothbrush_holder', 'curtain', 'rag', 'diary', 'cards', 'cupboard', 'controller', 'laundry_detergent', 'soap', 'tooth_paste', 'washing_machine', 'creditcard'] Task:Wash clothes response:

{ I go to the bedroom to find and grab basket of clothes. I then go to the bathroom and find the washing machine. I put clothes inside the washing machine and put washing powder. I switch on the washing machine. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'toilet', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'computer', 'tvstand', 'shower', 'closetdrawer', 'pillow', 'food_kiwi', 'wall', 'nightstand', 'powersocket', 'cup', 'bed', 'coffe_maker', 'food_food', 'doorjamb', 'towel_rack', 'pencil', 'headset', 'chessboard', 'dresser', 'hairbrush', 'door', 'clothes_scarf', 'light'] Task:Turn on light response: { thoughts : I go into my room, find the light, then turn on the lights., actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[WALK] <light>', '[SWITCHON] <light>'] } Scene_Objects:['sheets', 'pot', 'tablelamp', 'microwave', 'detergent', 'clothes_underwear', 'ceiling', 'character', 'desk', 'mail', 'table_cloth', 'bookmark', 'shoe-shine_kit', 'faucet', 'electric_shaver', 'mousepad', 'candle', 'food_jam', 'food_orange', 'nightstand', 'powersocket', 'newspaper', 'coin', 'food_onion', 'pencil', 'dresser', 'home_office', 'dishwasher', 'tooth_paste', 'coffee'] Task:Browse internet response:

{ The task is browse and surf on the internet regarding a particular topic }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'filing_cabinet', 'food_salt', 'toilet', 'detergent', 'cpuscreen', 'food_egg', 'bathroom_counter', 'floor', 'folder', 'desk', 'envelope', 'clothes_jacket', 'mat', 'plate', 'stereo', 'deck_of_cards', 'shower', 'couch', 'television', 'oven_mitts', 'curtain', 'shaving_cream', 'chessboard', 'cupboard', 'conditioner', 'light', 'table', 'soap', 'clothes_shirt'] Task:Dust response: { thoughts : Get a broom or duster with long handle. Dust blades of ceiling fan., actions : ['[WALK] <bedroom>', '[WALK] <duster>', '[FIND] <duster>', '[GRAB] <duster>', '[PUTOBJBACK] <duster>'] } Scene_Objects:['chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'stamp', 'keyboard', 'computer', 'bookmark', 'ceilinglamp', 'mat', 'mousepad', 'clothes_pants', 'wall', 'cutting_board', 'food_cheese', 'keys', 'food_food', 'video_game_controller', 'toothbrush_holder', 'mouse', 'pencil', 'door', 'sink', 'table', 'light', 'dirt'] Task:Browse internet response:

{ Go to home office, turn on the computer, open the internet and browse around the internet. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'pot', 'bathroom', 'knifeblock', 'bathroom_counter', 'shampoo', 'phone', 'mail', 'clothes_jacket', 'stovefan', 'ceilinglamp', 'window', 'clothes_socks', 'couch', 'clothes_pants', 'wall', 'powersocket', 'oven', 'photoframe', 'coffe_maker', 'television', 'mouse', 'shoes', 'chessboard', 'dresser', 'cupboard', 'bathroom_cabinet', 'table', 'dishwasher', 'clothes_shirt'] Task:Get dressed response: { thoughts : Open drawer. Pull out pants and put them on. Take a shirt out and put it on. Put on socks and shoes., actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTON] <clothes_pants>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTON] <clothes_shirt>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTON] <clothes_socks>', '[CLOSE] <dresser>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>'] } Scene_Objects:['glue', 'filing_cabinet', 'toilet', 'food_butter', 'orchid', 'bathroom_counter', 'bedroom', 'tea_bag', 'bookshelf', 'stovefan', 'ceilinglamp', 'faucet', 'shower', 'window', 'food_noodles', 'couch', 'clothes_hat', 'pillow', 'bench', 'powersocket', 'basket_for_clothes', 'television', 'oven_mitts', 'kitchen_counter', 'shoes', 'pajamas', 'door', 'light', 'soap', 'washing_machine'] Task:Wash clothes response:

{ Get dirty clothes out of basket for clothes in bedroom, carry dirty clothes to laundry room, place dirty clothes in washing machine, add laundry detergent to washing machine, turn washing machine on, set type of wash, start washing machine }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'filing_cabinet', 'food_ice_cream', 'beer', 'microwave', 'freezer', 'walllamp', 'floor', 'ceiling', 'phone', 'dvd_player', 'stovefan', 'ceilinglamp', 'toaster', 'mousepad', 'wall', 'wall_clock', 'cup', 'bed', 'food_food', 'coin', 'food_rice', 'water', 'pencil', 'shoes', 'controller', 'napkin', 'bathroom_cabinet', 'table', 'dishwasher'] Task:Drink response: { thoughts : Feeling tired after hard work I opened the fridge and grabbed cool water and drank from the glass., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <freezer>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <cup>', '[POUR] <water> <cup>', '[FIND] <cup>', '[DRINK] <cup>'] } Scene_Objects:['spectacles', 'sponge', 'measuring_cup', 'walllamp', 'nail_polish', 'drawing', 'orchid', 'floor', 'ceiling', 'dvd_player', 'keyboard', 'computer', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'window', 'couch', 'pillow', 'broom', 'wall', 'powersocket', 'oven', 'television', 'oven_mitts', 'curtain', 'doorjamb', 'mouse', 'bag', 'table'] Task:Relax on sofa response:

{ I sit on the sofa. I put my legs on the sofa and recline. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'filing_cabinet', 'freezer', 'blow_dryer', 'walllamp', 'drawing', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'ceiling', 'character', 'faucet', 'picture', 'iron', 'mousepad', 'bowl', 'wall', 'powersocket', 'bench', 'photoframe', 'toilet_paper', 'coffe_maker', 'toothbrush_holder', 'tray', 'doorjamb', 'dishrack', 'sink', 'bathroom_cabinet', 'home_office', 'light'] Task:Get toilet paper response: { thoughts : There are extra toilet papers in the bottom cabinet., actions : ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <toilet_paper>', '[GRAB] <toilet_paper>', '[CLOSE] <bathroom_cabinet>'] } Scene_Objects:['pot', 'filing_cabinet', 'toilet', 'trashcan', 'dough', 'food_carrot', 'knife', 'drawing', 'clothes_underwear', 'hanger', 'dvd_player', 'character', 'bookmark', 'toaster', 'mat', 'faucet', 'oven', 'tape', 'food_food', 'television', 'coffee_filter', 'ice', 'wooden_spoon', 'tray', 'lighter', 'chessboard', 'spoon', 'home_office', 'table', 'clothes_shirt'] Task:Pick up phone response:

{ I hear the phone ringing in the living room. I walk to the living room and go to the phone. I pick it up and answer the phone. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'bathroom', 'trashcan', 'food_butter', 'drawing', 'floor', 'ceiling', 'phone', 'mat', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'food_food', 'check', 'television', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'dresser', 'door', 'sink', 'spoon', 'home_office', 'light'] Task:Turn on light response: { thoughts : walk in kitchen. switch on light. walk in living room. switch on light.walk in entrance hall. switch on light., actions : ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <home_office>', '[WALK] <home_office>'] } Scene_Objects:['freezer', 'bathroom', 'detergent', 'cat', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'mousepad', 'form', 'wall', 'powersocket', 'photoframe', 'food_food', 'check', 'coffee_filter', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'controller', 'door', 'light', 'coffee'] Task:Put groceries in Fridge response:

{ I take the groceries out of the grocery bags, throw away grocery bags, categorize the food so that I know where it goes in the fridge, open the fridge, and place each item in the fridge before closing the fridge. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_ice_cream', 'toilet', 'walllamp', 'nail_polish', 'dough', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'cards', 'dishrack', 'door', 'light'] Task:Change TV channel response: { thoughts : first i will go to living room and then take the remote and swtitch on television after that il change the channel, actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>', '[TOUCH] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['spectacles', 'pot', 'filing_cabinet', 'crayon', 'walllamp', 'drawing', 'knifeblock', 'orchid', 'floor', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'window', 'couch', 'food_orange', 'pillow', 'dining_room', 'wall', 'powersocket', 'bench', 'cutting_board', 'curtain', 'cards', 'dresser', 'bag', 'table', 'light', 'colander', 'clothes_shirt'] Task:Relax on sofa response:

{ Walk to the living room, turn to the sofa. Sit on the sofa and relax. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['toilet', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'bedroom', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'mousepad', 'couch', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'oven', 'television', 'toothbrush_holder', 'curtain', 'doorjamb', 'console', 'dresser', 'cupboard', 'home_office', 'table', 'clothes_skirt', 'vase'] Task:Watch TV response: { thoughts : Watch the television, actions : ['[WALK] <home_office>', '[WALK] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[SWITCHON] <television>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['pot', 'tablelamp', 'chair', 'freezer', 'walllamp', 'food_butter', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'mat', 'ceilinglamp', 'mousepad', 'wall', 'powersocket', 'photoframe', 'newspaper', 'ice', 'curtain', 'mouse', 'headset', 'hairbrush', 'door', 'bathroom_cabinet', 'table', 'clothes_shirt'] Task:Write an email response:

{ walk into office, sit in chair, turn on computer, write email }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'toilet', 'freezer', 'detergent', 'knifeblock', 'phone', 'bookshelf', 'computer', 'mop_bucket', 'brush', 'clothes_socks', 'mousepad', 'dining_room', 'nightstand', 'basket_for_clothes', 'food_food', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'laundry_detergent', 'bathtub', 'sink', 'home_office', 'napkin', 'dishwasher', 'bathroom_cabinet', 'washing_machine'] Task:Wash clothes response: { thoughts : I walk to entrance hall I walk to bedroom I find basket of clothes I lift basket of clothes I walk to kitchen I find washing machine I open washing machine I put laundry in washing machine I add laundry detergent I close washing machine lid I switch washing machine on , actions : ['[WALK] <home_office>', '[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[TURNTO] <washing_machine>'] } Scene_Objects:['sheets', 'mop', 'microwave', 'ground_coffee', 'walllamp', 'cat', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'toaster', 'brush', 'tvstand', 'shower', 'faucet', 'food_jam', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'mouthwash', 'coffee_filter', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'dishwasher', 'scrabble'] Task:Make coffee response:

{ Make coffee in the kitchen. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'filing_cabinet', 'food_pizza', 'walllamp', 'orchid', 'needle', 'cpuscreen', 'bathroom_counter', 'shampoo', 'desk', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'toaster', 'shower', 'faucet', 'couch', 'dining_room', 'cup', 'bed', 'tray', 'curtain', 'wooden_spoon', 'pencil', 'door', 'bathroom_cabinet', 'light', 'dishwasher', 'table'] Task:Pick up phone response: { thoughts : I walk to the home office. I find the telephone. I pick up the telephone handset., actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>'] } Scene_Objects:['sheets', 'food_pizza', 'filing_cabinet', 'dog', 'bathroom', 'knifeblock', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'character', 'desk', 'bedroom', 'clothes_jacket', 'mat', 'tvstand', 'pillow', 'towel', 'wall', 'cup', 'food_donut', 'curtain', 'after_shave', 'dishrack', 'cupboard', 'controller', 'door', 'dishwasher'] Task:Pick up phone response:

{ Walk to living room. Go near telephone. take the receiver and then talk to other person on that side. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'toilet', 'walllamp', 'bathroom', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'tvstand', 'faucet', 'plate', 'mousepad', 'wall', 'powersocket', 'bench', 'oven', 'cutting_board', 'tape', 'cup', 'doorjamb', 'sink', 'light', 'table'] Task:Pick up phone response: { thoughts : walk over and pick up the phone, actions : ['[WALK] <phone>', '[GRAB] <phone>'] } Scene_Objects:['tablelamp', 'toilet', 'chair', 'freezer', 'walllamp', 'bathroom', 'nail_polish', 'detergent', 'trashcan', 'drawing', 'floor', 'ceiling', 'desk', 'stamp', 'keyboard', 'computer', 'table_cloth', 'stereo', 'mousepad', 'broom', 'wall', 'nightstand', 'powersocket', 'oven', 'television', 'rag', 'mouse', 'headset', 'door', 'shoe_rack'] Task:Listen to music response:

{ I walk to my bedroom. I locate my stereo and turn it on. I put on my headphones and sit to listen. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'tea_bag', 'bookshelf', 'keyboard', 'brush', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'stovefan', 'shoe-shine_kit', 'pillow', 'wall', 'powersocket', 'photoframe', 'novel', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'bathroom_cabinet', 'light'] Task:Watch TV response: { thoughts : Walk into the living room. Sit on the couch. Turn on TV., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>'] } Scene_Objects:['microwave', 'toilet', 'band-aids', 'detergent', 'toothbrush', 'drawing', 'needle', 'bathroom_counter', 'floor', 'ceiling', 'purse', 'stovefan', 'mat', 'tvstand', 'faucet', 'brush', 'window', 'oil', 'couch', 'bowl', 'wall', 'powersocket', 'coffee_pot', 'pencil', 'food_steak', 'sink', 'bag', 'bathroom_cabinet', 'tooth_paste', 'teeth'] Task:Wash teeth response:

{ I walk in to the bathroom. I turn on the faucet. I find the toothbrush and toothpaste. I grab the toothbrush and toothpaste. I rinse off the toothbrush. I add toothpaste to the toothbrush. I put back the toothpaste. I wash my teeth with the toothbrush. I rinse off the toothbrush. I put the toothbrush back. I rinse my mouth out. I turn the faucet off. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'walllamp', 'detergent', 'toothbrush', 'drawing', 'cpuscreen', 'food_egg', 'phone', 'character', 'computer', 'piano_bench', 'shoe-shine_kit', 'faucet', 'food_noodles', 'mousepad', 'clothes_hat', 'towel', 'broom', 'cutting_board', 'shelf', 'keys', 'novel', 'food_food', 'check', 'wooden_spoon', 'towel_rack', 'sink', 'table', 'light', 'coffee'] Task:Change TV channel response: { thoughts : I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>'] } Scene_Objects:['dry_pasta', 'filing_cabinet', 'tablelamp', 'beer', 'bathroom', 'food_butter', 'food_carrot', 'milk', 'bathroom_counter', 'bedroom', 'thread', 'table_cloth', 'bookmark', 'ceilinglamp', 'shower', 'mousepad', 'nightstand', 'powersocket', 'box', 'photoframe', 'razor', 'wine', 'dresser', 'clothes_scarf', 'sink', 'home_office', 'light', 'colander', 'laser_pointer', 'dirt'] Task:Pet cat response:

{ Petting the cat }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_pizza', 'freezer', 'trashcan', 'drawing', 'bathroom_counter', 'ceiling', 'phone', 'thread', 'computer', 'stovefan', 'faucet', 'shower', 'food_jam', 'dining_room', 'wall', 'powersocket', 'tape', 'coffe_maker', 'food_food', 'mirror', 'doorjamb', 'mouse', 'paper_towel', 'dresser', 'cupboard', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'home_office', 'dirt'] Task:Clean mirror response: { thoughts : Spray Windex or glass and mirror cleaner onto mirror. Use paper towel to wipe off cleaner until mirror is dry and has no streaks., actions : ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[CLOSE] <bathroom_cabinet>', '[WALK] <mirror>', '[WIPE] <mirror>', '[FIND] <trashcan>', '[PUTBACK] <paper_towel> <trashcan>'] } Scene_Objects:['fork', 'pot', 'measuring_cup', 'microwave', 'detergent', 'trashcan', 'orchid', 'bills', 'knife', 'bathroom_counter', 'floor', 'character', 'keyboard', 'mat', 'mousepad', 'nightstand', 'pasta', 'tape', 'novel', 'food_food', 'check', 'television', 'curtain', 'coffee_pot', 'laundry_detergent', 'clothes_scarf', 'bathroom_cabinet', 'colander', 'instrument_violin', 'washing_machine'] Task:Wash clothes response:

{ Go to bedroom and grab dirty pants and take to the washing machine in entrance hall. Put clothes in washing machine and then put in laundry detergent. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'walllamp', 'woman', 'toothbrush', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'stamp', 'bookshelf', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'wall', 'child', 'box', 'photoframe', 'television', 'oven_mitts', 'doorjamb', 'cd', 'dresser', 'table'] Task:Watch movie response: { thoughts : Sitting and watching a movie with family, actions : ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[TURNTO] <child>', '[LOOKAT] <child>', '[GREET] <child>', '[FIND] <woman>', '[TURNTO] <woman>', '[LOOKAT] <woman>', '[GREET] <woman>', '[WALK] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[WATCH] <television>', '[WATCH] <television>'] } Scene_Objects:['food_pizza', 'blender', 'walllamp', 'cat', 'drawing', 'orchid', 'needle', 'bathroom_counter', 'floor', 'bedroom', 'desk', 'ceilinglamp', 'laptop', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'bench', 'oven', 'newspaper', 'check', 'tray', 'curtain', 'doorjamb', 'door', 'bathroom_cabinet', 'table', 'tooth_paste', 'coffee'] Task:Relax on sofa response:

{ I'm tired and want to relax on the sofa }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'walllamp', 'trashcan', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'folder', 'bedroom', 'food_cake', 'computer', 'shower', 'iron', 'window', 'pillow', 'wall', 'nightstand', 'powersocket', 'tape', 'bed', 'television', 'wine', 'doorjamb', 'towel_rack', 'dresser', 'home_office', 'light', 'bathroom_cabinet', 'dishwasher'] Task:Pick up phone response: { thoughts : I walk to the kitchen and find the phone. I pick up the phone. I hold it to my ear., actions : ['[WALK] <dining_room>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>'] } Scene_Objects:['water_glass', 'filing_cabinet', 'food_salt', 'microwave', 'blow_dryer', 'detergent', 'knife', 'orchid', 'bathroom_counter', 'shampoo', 'keyboard', 'bookshelf', 'mail', 'stovefan', 'ceilinglamp', 'toaster', 'mat', 'faucet', 'food_peanut_butter', 'dining_room', 'nightstand', 'oven', 'cup', 'light_bulb', 'food_food', 'television', 'food_onion', 'pencil', 'napkin', 'light'] Task:Drink response:

{ Walk to kitchen. Find water glass. Grab water glass. Find water. Pour water in water glass. Drink water from water glass. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['toilet', 'freezer', 'food_butter', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'mop_bucket', 'ceilinglamp', 'tvstand', 'iron', 'window', 'mousepad', 'microphone', 'towel', 'dining_room', 'bowl', 'wall', 'powersocket', 'bench', 'cup', 'novel', 'television', 'coin', 'rag', 'doorjamb', 'headset', 'light'] Task:Turn on light response: { thoughts : I walk in to the living room. I find the light switch. I turn on the lights., actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['filing_cabinet', 'juice', 'measuring_cup', 'microwave', 'walllamp', 'trashcan', 'floor', 'bedroom', 'computer', 'toaster', 'stovefan', 'ceilinglamp', 'faucet', 'window', 'mousepad', 'candle', 'pillow', 'wall', 'nightstand', 'bench', 'oven', 'cup', 'newspaper', 'coffe_maker', 'tray', 'kitchen_counter', 'cupboard', 'home_office', 'dishwasher', 'laser_pointer'] Task:Wash dishes with dishwasher response:

{ Walk to the sink. Take dishes out of sink. Open dishwasher and place dishes in dishwasher. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['water_glass', 'food_bread', 'chair', 'freezer', 'walllamp', 'detergent', 'trashcan', 'drawing', 'desk', 'keyboard', 'bookshelf', 'bookmark', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'faucet', 'pillow', 'bowl', 'wall', 'box', 'coffe_maker', 'razor', 'television', 'curtain', 'doorjamb', 'towel_rack', 'door', 'sink', 'bathroom_cabinet'] Task:Drink response: { thoughts : Pour water into a glass and drink from the glass., actions : ['[WALK] <dining_room>', '[WALK] <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>'] } Scene_Objects:['freezer', 'ground_coffee', 'bathroom', 'drawing', 'floor', 'ceiling', 'bookshelf', 'mat', 'ceilinglamp', 'stereo', 'mousepad', 'couch', 'clothes_pants', 'dining_room', 'wall', 'powersocket', 'box', 'bed', 'check', 'television', 'wooden_spoon', 'after_shave', 'doorjamb', 'pencil', 'kitchen_counter', 'door', 'food_steak', 'napkin', 'light', 'board_game'] Task:Turn on light response:

{ switching on the light }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'envelope', 'computer', 'button', 'food_bacon', 'table_cloth', 'mat', 'tvstand', 'ceilinglamp', 'shoe-shine_kit', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'cup', 'photoframe', 'television', 'doorjamb', 'dresser', 'dirt'] Task:Change TV channel response: { thoughts : Pickup remote control for the living room TV and push the change channel button, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['pot', 'tablelamp', 'cpuscreen', 'clothes_underwear', 'hanger', 'shampoo', 'bookshelf', 'alcohol', 'table_cloth', 'faucet', 'shower', 'clothes_socks', 'clothes_pants', 'wall', 'wall_clock', 'oven', 'nightstand', 'basket_for_clothes', 'newspaper', 'clothes_gloves', 'tray', 'doorjamb', 'lighter', 'cards', 'clothes_dress', 'laundry_detergent', 'napkin', 'clothes_skirt', 'clothes_shirt', 'washing_machine'] Task:Wash clothes response:

{ I go to the bathroom, take the dirt clothes and put into the washing machine, then put the soap, set the cleaning program and switch on the machine }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tea', 'cat', 'drawing', 'bills', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'mail', 'alcohol', 'mat', 'faucet', 'clothes_pants', 'pillow', 'wall', 'wall_clock', 'oven', 'pasta', 'bench', 'coffee_filter', 'ice', 'paper_towel', 'conditioner', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'soap', 'hands_both', 'shoe_rack'] Task:Wash hands response: { thoughts : I walk to the bathroom and find the sink. I grab the soap and rub some on my hands. I turn the faucet on and put my hands in the water. I rinse my hands and then turn off the faucet. Then I dry my hands on a paper towel., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <hands_both>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[WIPE] <hands_both>'] } Scene_Objects:['chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'faucet', 'picture', 'window', 'mousepad', 'oil', 'clothes_hat', 'wall', 'keys', 'food_food', 'coin', 'food_onion', 'mouse', 'cupboard', 'laundry_detergent', 'door', 'table'] Task:Write an email response:

{ I walk into the home office and walk to the desk. I pull out the chair and sit down. I turn on the computer. After the computer is turned on I click on my email program. When the program is loaded I write an email. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'measuring_cup', 'dog', 'freezer', 'walllamp', 'orchid', 'bathroom_counter', 'keyboard', 'bookshelf', 'closetdrawer', 'pillow', 'dining_room', 'powersocket', 'oven', 'newspaper', 'clothes_gloves', 'bed', 'check', 'doorjamb', 'diary', 'towel_rack', 'mouse', 'cd', 'cupboard', 'door', 'napkin', 'home_office', 'bathroom_cabinet', 'dishwasher', 'scrabble'] Task:Read book response: { thoughts : Read a book, actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>', '[PUTOBJBACK] <novel>'] } Scene_Objects:['filing_cabinet', 'microwave', 'walllamp', 'trashcan', 'knifeblock', 'floor', 'character', 'desk', 'bedroom', 'keyboard', 'thread', 'toaster', 'plate', 'couch', 'wall', 'light_bulb', 'novel', 'coffe_maker', 'food_rice', 'tray', 'food_onion', 'after_shave', 'curtain', 'kettle', 'kitchen_counter', 'shoes', 'cupboard', 'conditioner', 'door', 'dishwasher'] Task:Wash dishes with dishwasher response:

{ In the kitchen, open up the dishwasher. Take plates from the sink and put them in the dishwasher one by one. Close the dishwasher. Program it. Push start. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'mop', 'chair', 'bathroom', 'food_carrot', 'woman', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'man', 'keyboard', 'mat', 'faucet', 'window', 'foundation', 'nightstand', 'powersocket', 'cup', 'coffe_maker', 'food_food', 'television', 'tray', 'towel_rack', 'cd', 'dresser', 'sink', 'clothes_scarf', 'light'] Task:Greet guests response: { thoughts : Stand next to the door. When the door opens from the outside, greet the guests., actions : ['[RUN] <home_office>', '[WALK] <woman>', '[FIND] <woman>', '[TURNTO] <woman>', '[LOOKAT] <woman>', '[GREET] <woman>', '[FIND] <man>', '[TURNTO] <man>', '[LOOKAT] <man>', '[GREET] <man>'] } Scene_Objects:['food_ice_cream', 'measuring_cup', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'keyboard', 'mail', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'window', 'couch', 'candle', 'pillow', 'bowl', 'wall', 'powersocket', 'television', 'curtain', 'after_shave', 'doorjamb', 'chessboard', 'door', 'food_steak', 'bathroom_cabinet', 'table', 'board_game'] Task:Watch TV response:

{ I walk to the living room. I grab the remote control. I walk to the sofa. I sit down, and press the on button on the remote. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'tea', 'ground_coffee', 'walllamp', 'hanger', 'longboard', 'floor', 'ceiling', 'button', 'toaster', 'faucet', 'mousepad', 'candle', 'wall', 'nightstand', 'powersocket', 'keys', 'novel', 'coffe_maker', 'clothes_gloves', 'coffee_filter', 'water', 'ice', 'tray', 'food_onion', 'cupboard', 'door', 'light', 'dishwasher', 'soap'] Task:Make coffee response: { thoughts : Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker., actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>'] } Scene_Objects:['sponge', 'microwave', 'walllamp', 'bathroom', 'toothbrush', 'drawing', 'orchid', 'floor', 'desk', 'computer', 'ceilinglamp', 'mat', 'deck_of_cards', 'stereo', 'window', 'couch', 'food_jam', 'pillow', 'wall', 'light_bulb', 'food_donut', 'tray', 'curtain', 'shoes', 'dishrack', 'sink', 'spoon', 'table', 'dishwasher', 'coffee'] Task:Relax on sofa response:

{ I walk to the living room. I see the couch. I sit down on the couch, then lie down and put my feet up. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_salt', 'toilet', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'floor', 'tea_bag', 'bookshelf', 'food_bacon', 'toaster', 'plate', 'tvstand', 'dish_soap', 'mousepad', 'couch', 'wall', 'oven', 'powersocket', 'photoframe', 'coffe_maker', 'food_food', 'toothbrush_holder', 'ice', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'clothes_dress', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : Go to kitchen to put dirty dishs into dishwasher with soap to clean the dirty dishes, actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['water_glass', 'pot', 'freezer', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'oil', 'mousepad', 'food_peanut_butter', 'wall', 'oven', 'powersocket', 'food_food', 'water', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light'] Task:Drink response:

{ I need to go to Kitchen. Get a cup. Fill cup. Drink }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'tablelamp', 'microwave', 'chair', 'wallshelf', 'hanger', 'floor', 'phone', 'food_bacon', 'piano_bench', 'stovefan', 'ceilinglamp', 'shower', 'mousepad', 'closetdrawer', 'powersocket', 'television', 'coin', 'food_donut', 'ice', 'rag', 'pencil', 'shoes', 'dresser', 'clothes_dress', 'clothes_scarf', 'sink', 'bathroom_cabinet', 'light', 'home_office'] Task:Hang up jacket response: { thoughts : I put clothes on hangers and hang them in the closet, actions : ['[WALK] <bedroom>', '[WALK] <clothes_dress>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[WALK] <dresser>', '[FIND] <hanger>', '[OPEN] <dresser>', '[PUTIN] <clothes_dress> <dresser>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[WALK] <dresser>', '[PUTIN] <clothes_dress> <dresser>', '[CLOSE] <dresser>'] } Scene_Objects:['glue', 'microwave', 'walllamp', 'ground_coffee', 'trashcan', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'iron', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'kitchen_counter', 'door', 'table'] Task:Watch TV response:

{ Go to the sofa and watch TV }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['glue', 'pot', 'scissors', 'walllamp', 'detergent', 'drawing', 'clothes_underwear', 'floor', 'phone', 'character', 'button', 'toaster', 'plate', 'tvstand', 'dish_soap', 'oil', 'candle', 'wall', 'oven', 'tape', 'box', 'coffe_maker', 'food_food', 'check', 'tray', 'centerpiece', 'controller', 'light', 'dishwasher', 'soap'] Task:Wash dishes with dishwasher response: { thoughts : walk into kitchen, find dishwasher, put plates in dishwasher, put soap in dishwasher, turn on dishwasher, actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['pot', 'freezer', 'walllamp', 'bathroom', 'drawing', 'floor', 'ceiling', 'bookshelf', 'envelope', 'toaster', 'mat', 'food_orange', 'pillow', 'wall', 'wall_clock', 'powersocket', 'cutting_board', 'bed', 'oven_mitts', 'coin', 'doorjamb', 'lighter', 'pencil', 'kitchen_counter', 'dresser', 'pajamas', 'door', 'home_office', 'light', 'colander'] Task:Turn on light response:

{ I walk towards to the bedroom, and I open the door of the bedroom, and I switch on the lights inside the bedroom, the switch is beside the door. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'juice', 'blow_dryer', 'walllamp', 'detergent', 'floor', 'ceiling', 'bedroom', 'keyboard', 'purse', 'tvstand', 'deck_of_cards', 'clothes_pants', 'dining_room', 'wall', 'nightstand', 'powersocket', 'oven', 'keys', 'tray', 'kettle', 'shoes', 'hair', 'sink', 'home_office', 'table', 'dishwasher', 'soap', 'board_game', 'dirt'] Task:Hang up car keys response: { thoughts : Open the front door. Enter the entrance hall. Take out car keys from purse. Hang car keys up on hook on the wall., actions : ['[WALK] <home_office>', '[WALK] <purse>', '[FIND] <purse>', '[OPEN] <purse>', '[FIND] <keys>', '[GRAB] <keys>', '[CLOSE] <purse>'] } Scene_Objects:['sponge', 'dry_pasta', 'beer', 'microwave', 'walllamp', 'bathroom', 'detergent', 'trashcan', 'drawing', 'knifeblock', 'floor', 'phone', 'bedroom', 'food_bacon', 'toaster', 'ceilinglamp', 'window', 'dish_soap', 'candle', 'pillow', 'bowl', 'wall', 'bench', 'newspaper', 'coffe_maker', 'kettle', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'dishwasher'] Task:Wash dishes with dishwasher response:

{ I go to the dishwasher and put dish soap. I close the dishwasher and turn it on. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'filing_cabinet', 'tablelamp', 'crayon', 'drawing', 'hanger', 'floor', 'character', 'bedroom', 'mat', 'window', 'towel', 'pillow', 'wall', 'nightstand', 'cutting_board', 'cup', 'bed', 'toilet_paper', 'food_donut', 'curtain', 'doorjamb', 'mouse', 'shoes', 'chessboard', 'controller', 'laundry_detergent', 'door', 'table', 'vase'] Task:Go to sleep response: { thoughts : go t the bedroom and go to sleep, actions : ['[WALK] <bedroom>', '[WALK] <bed>', '[FIND] <bed>', '[LIE] <bed>'] } Scene_Objects:['glue', 'filing_cabinet', 'food_salt', 'microwave', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'stovefan', 'mat', 'dustpan', 'food_orange', 'wall', 'powersocket', 'oven', 'photoframe', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'pajamas', 'cupboard', 'clothes_dress', 'door', 'light', 'dishwasher', 'table'] Task:Turn on light response:

{ Walk to the Living Room. Switch on 1 light. Walk to dining room. Switch on 1 light. Walk to Entrance hall. Switch on 1 light. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['juice', 'toilet', 'chair', 'detergent', 'bathroom_counter', 'ceiling', 'character', 'desk', 'laptop', 'tvstand', 'faucet', 'electric_shaver', 'mousepad', 'couch', 'food_orange', 'bench', 'powersocket', 'cup', 'bed', 'novel', 'razor', 'oven_mitts', 'curtain', 'after_shave', 'cd', 'headset', 'dresser', 'pajamas', 'bathroom_cabinet', 'tooth_paste'] Task:Pick up phone response: { thoughts : I'll enter the location containing the phone. Once there, I'll locate the phone, and move close to it. I'll then use my hand to pick up the phone such that I can then use it., actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[WALK] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[GRAB] <phone>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'mail', 'stovefan', 'ceilinglamp', 'mat', 'mousepad', 'dustpan', 'wall', 'bed', 'coffe_maker', 'lighter', 'coffee_pot', 'mouse', 'hair', 'door', 'napkin', 'home_office', 'table'] Task:Browse internet response:

{ Go find a computer, turn it on, click google, and browse the internet. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'tablelamp', 'walllamp', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'keyboard', 'computer', 'clothes_jacket', 'mat', 'faucet', 'shower', 'towel', 'pillow', 'wall', 'nightstand', 'oven', 'food_food', 'tray', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'board_game', 'hands_both'] Task:Wash hands response: { thoughts : I go to the bathroom, open the faucet rinse the hands, wash the hands with soap and rinse again, then wipe with a towel., actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[TURNTO] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>'] } Scene_Objects:['food_pizza', 'chair', 'freezer', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mop_bucket', 'ceilinglamp', 'mat', 'electric_shaver', 'mousepad', 'wall', 'powersocket', 'photoframe', 'food_food', 'coffe_maker', 'mouse', 'pencil', 'controller', 'door', 'table', 'teeth'] Task:Work response:

{ walk to home office ,find computer ,switch on computer and work }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mail', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'home_office'] Task:Check email response: { thoughts : Turn on the computer. Wait for it to load. Get online. Go to the email service. Open the email. Read the email., actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mail>', '[GRAB] <mail>', '[READ] <mail>'] } Scene_Objects:['blender', 'food_ice_cream', 'walllamp', 'bathroom', 'knifeblock', 'cpuscreen', 'character', 'envelope', 'stovefan', 'stereo', 'shower', 'window', 'towel', 'dining_room', 'broom', 'nightstand', 'cup', 'basket_for_clothes', 'check', 'food_rice', 'doorjamb', 'diary', 'mouse', 'kitchen_counter', 'chessboard', 'hairbrush', 'hair', 'dresser', 'light', 'shoe_rack'] Task:Read book response:

{ Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'microwave', 'walllamp', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'folder', 'character', 'desk', 'faucet', 'stereo', 'mousepad', 'food_orange', 'wall', 'oven', 'photoframe', 'oven_mitts', 'water', 'drinking_glass', 'wooden_spoon', 'towel_rack', 'shaving_cream', 'kitchen_counter', 'cupboard', 'food_steak', 'sink', 'spoon', 'board_game'] Task:Drink response: { thoughts : Go to kitchen, open cabinet, get glass, close cabinet, put glass under faucet, turn on water, turn off water when glass has 85% water, lift glass to mouth, open mouth and put on glass, tilt glass up and swallow water., actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[TURNTO] <kitchen_cabinet>', '[LOOKAT] <kitchen_cabinet>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[FIND] <sink>', '[PUTBACK] <drinking_glass> <sink>', '[GRAB] <drinking_glass>', '[SWITCHOFF] <faucet>', '[DRINK] <drinking_glass>'] } Scene_Objects:['pot', 'food_ice_cream', 'tea', 'walllamp', 'ground_coffee', 'detergent', 'trashcan', 'milk', 'drawing', 'knifeblock', 'orchid', 'floor', 'phone', 'bookshelf', 'stovefan', 'ceilinglamp', 'deck_of_cards', 'shower', 'window', 'couch', 'dustpan', 'pillow', 'dining_room', 'wall', 'nightstand', 'toy', 'photoframe', 'food_food', 'curtain', 'table'] Task:Relax on sofa response:

{ I walk into the living room. I bend down. I sit on the sofa. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'shampoo', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'food_food', 'television', 'doorjamb', 'mouse', 'dresser', 'door'] Task:Work response: { thoughts : I go to my office. I switch the computer on and sit on the office chair. I look at the computer screen to see what needs to be done. I use my mouse to navigate to the relevant directory, then release it. I type code with my keyboard. When I'm done, I look at the computer again to evaluate what I've done. Then I switch off the computer using the mouse and put back the mouse., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[PUTOBJBACK] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[GRAB] <mouse>', '[SWITCHOFF] <computer>', '[PUTOBJBACK] <mouse>'] } Scene_Objects:['pot', 'chair', 'freezer', 'walllamp', 'detergent', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'cutting_board', 'bed', 'television', 'curtain', 'doorjamb', 'hairbrush', 'controller', 'door', 'table', 'dishwasher', 'instrument_violin'] Task:Watch TV response:

{ go to the living room. find the remote. sit on the couch. turn on the tv. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'mop', 'bathroom', 'knife', 'hanger', 'bathroom_counter', 'ceiling', 'bedroom', 'desk', 'food_cake', 'window', 'electric_shaver', 'microphone', 'food_jam', 'dining_room', 'wall', 'photoframe', 'food_food', 'television', 'curtain', 'mouse', 'kitchen_counter', 'cd', 'chessboard', 'dresser', 'hairbrush', 'clothes_scarf', 'bathroom_cabinet', 'dishwasher', 'instrument_violin'] Task:Put on coat response: { thoughts : I remove my scarf from a coat peg in the entrance hall. I wrap the scarf around my neck, actions : ['[WALK] <home_office>', '[WALK] <hanger>', '[TURNTO] <hanger>', '[LOOKAT] <hanger>', '[FIND] <clothes_scarf>', '[GRAB] <clothes_scarf>', '[PUTON] <clothes_scarf>'] } Scene_Objects:['pot', 'measuring_cup', 'microwave', 'chair', 'food_butter', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'desk', 'food_bacon', 'mat', 'tvstand', 'form', 'pillow', 'dining_room', 'wall', 'bench', 'cup', 'light_bulb', 'television', 'kettle', 'kitchen_counter', 'cd', 'cupboard', 'clothes_dress', 'door', 'bathroom_cabinet'] Task:Pick up phone response:

{ I walk over to the phone. .I reach my arm out. I open my hand. I place my hand on the phone. I close my fingers around the phone. I pick up the phone. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'food_kiwi', 'wall', 'nightstand', 'oven', 'photoframe', 'television', 'doorjamb', 'headset', 'dresser', 'bathroom_cabinet', 'soap'] Task:Change TV channel response: { thoughts : I find the remote then I push the button to switch it to the tv channel i want to watch, actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[PUSH] <remote_control>'] } Scene_Objects:['dry_pasta', 'sheets', 'filing_cabinet', 'tablelamp', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'kitchen_cabinet', 'ceiling', 'bookshelf', 'piano_bench', 'plate', 'shower', 'window', 'couch', 'dining_room', 'pasta', 'oven', 'bench', 'television', 'water', 'drinking_glass', 'curtain', 'doorjamb', 'clothes_scarf', 'napkin', 'light', 'dishwasher', 'colander'] Task:Drink response:

{ You walk to the kitchen and open the kitchen cabinet and grab a drinking glass. You find the water and pour the water into the drinking glass. You drink the water from the glass. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'filing_cabinet', 'freezer', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'clothes_jacket', 'table_cloth', 'mat', 'food_kiwi', 'wall', 'powersocket', 'clothes_gloves', 'food_food', 'coffe_maker', 'doorjamb', 'coffee_pot', 'headset', 'door', 'hairdryer', 'light', 'tooth_paste'] Task:Turn on light response: { thoughts : I walk towards to the bedroom, and I open the door of the bedroom, and I switch on the lights inside the bedroom, the switch is beside the door., actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'food_pizza', 'food_salt', 'microwave', 'floor', 'phone', 'ceiling', 'bedroom', 'computer', 'table_cloth', 'stovefan', 'shower', 'stereo', 'couch', 'clothes_pants', 'nightstand', 'oven', 'cup', 'photoframe', 'novel', 'television', 'food_donut', 'ice', 'doorjamb', 'mouse', 'light', 'colander', 'board_game'] Task:Listen to music response:

{ Walk into living room. Turn on radio. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'chair', 'freezer', 'drawing', 'needle', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'envelope', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'couch', 'dustpan', 'dining_room', 'wall', 'nightstand', 'powersocket', 'food_food', 'toilet_paper', 'doorjamb', 'coffee_pot', 'mouse', 'kettle', 'dresser', 'light'] Task:Turn on light response: { thoughts : walk into living room, walk to light, turn on light switch., actions : ['[WALK] <home_office>', '[WALK] <light>', '[SWITCHON] <light>'] } Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'phone', 'piano_bench', 'toaster', 'mat', 'faucet', 'shower', 'window', 'dining_room', 'wall', 'bench', 'hands_both', 'bed', 'television', 'oven_mitts', 'water', 'curtain', 'paper_towel', 'hairdryer', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'teeth'] Task:Wash hands response:

{ I walk into the bathroom. I turn on the water. I put soap on my hands. I rinse my hands. I turn off the water. I dry my hands. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'tablelamp', 'tea', 'drawing', 'wallshelf', 'hanger', 'ceiling', 'tea_bag', 'bookshelf', 'stovefan', 'toaster', 'mat', 'faucet', 'floor_lamp', 'mousepad', 'nightstand', 'box', 'bed', 'photoframe', 'novel', 'food_food', 'coffee_filter', 'food_donut', 'wine', 'after_shave', 'curtain', 'doorjamb', 'clothes_dress', 'conditioner', 'sink'] Task:Read book response: { thoughts : Turn a light on and read a book in the bedroom., actions : ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>'] } Scene_Objects:['dry_pasta', 'food_pizza', 'mop', 'cat', 'knife', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'shampoo', 'dvd_player', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'faucet', 'stereo', 'window', 'couch', 'towel', 'wall', 'novel', 'tray', 'doorjamb', 'hairbrush', 'sink', 'bathroom_cabinet', 'soap', 'hands_both', 'shoe_rack'] Task:Wash hands response:

{ I go to the sink, turn on the water, put soap on my hands, rub them together, then rinse them off and turn off the water. I then towel off my hands. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'crayon', 'chair', 'bathroom', 'food_butter', 'phone', 'ceiling', 'bedroom', 'tea_bag', 'laptop', 'ceilinglamp', 'shower', 'iron', 'clothes_socks', 'closetdrawer', 'clothes_pants', 'pillow', 'wall', 'powersocket', 'standingmirror', 'photoframe', 'toothbrush_holder', 'food_donut', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'controller', 'door', 'table'] Task:Switch on lamp response: { thoughts : Press the button so the light comes on., actions : ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>'] } Scene_Objects:['tea', 'toilet', 'freezer', 'band-aids', 'knifeblock', 'food_egg', 'shampoo', 'phone', 'bookshelf', 'purse', 'thread', 'deck_of_cards', 'shower', 'picture', 'clothes_socks', 'oven', 'food_cheese', 'novel', 'food_food', 'check', 'coffe_maker', 'tray', 'after_shave', 'curtain', 'doorjamb', 'cupboard', 'controller', 'bag', 'table', 'scrabble'] Task:Drink response:

{ Pour water into a glass and drink from the glass. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'pot', 'microwave', 'toilet', 'cat', 'wallshelf', 'bathroom_counter', 'floor', 'dvd_player', 'bookshelf', 'stovefan', 'ceilinglamp', 'toaster', 'mat', 'shower', 'faucet', 'tvstand', 'couch', 'towel', 'wall', 'bench', 'cutting_board', 'bed', 'razor', 'television', 'curtain', 'kitchen_counter', 'dresser', 'home_office', 'light'] Task:Pet cat response: { thoughts : Pet Cat, actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['sheets', 'filing_cabinet', 'blender', 'beer', 'freezer', 'band-aids', 'walllamp', 'orchid', 'food_egg', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'button', 'ceilinglamp', 'mousepad', 'food_peanut_butter', 'wall', 'powersocket', 'food_food', 'doorjamb', 'mouse', 'door', 'sink', 'napkin', 'light'] Task:Put groceries in Fridge response:

{ I walk in to the kitchen. I open the fridge. I place the groceries in the fridge. I close the fridge. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'measuring_cup', 'microwave', 'freezer', 'ceilingfan', 'milk', 'floor', 'ceiling', 'character', 'bedroom', 'computer', 'button', 'toaster', 'faucet', 'picture', 'wall', 'nightstand', 'oven', 'photoframe', 'clothes_gloves', 'coffe_maker', 'food_food', 'curtain', 'centerpiece', 'food_sugar', 'vacuum_cleaner', 'chessboard', 'coffee_cup', 'dishwasher', 'light'] Task:Make coffee response: { thoughts : walk to kitchen, look at the coffee maker, open the coffee maker, find milk, suger and water, mix that all, put into coffee maker, switch on the coffee maker, wait for few mins, push the coffee button in coffee maker, we get coffee in coffee cup, drink coffee, actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[TURNTO] <coffe_maker>', '[LOOKAT] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <milk>', '[GRAB] <milk>', '[PUTBACK] <milk> <coffe_maker>', '[FIND] <food_sugar>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[PUTBACK] <coffee_cup> <coffe_maker>', '[SWITCHON] <coffe_maker>', '[FIND] <button>', '[PUSH] <button>', '[GRAB] <coffee_cup>', '[DRINK] <coffee_cup>'] } Scene_Objects:['sheets', 'food_bread', 'tablelamp', 'crayon', 'walllamp', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'dvd_player', 'bedroom', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'coffe_maker', 'television', 'curtain', 'after_shave', 'doorjamb', 'door', 'bathroom_cabinet', 'table'] Task:Watch TV response:

{ You walk to the living room and sit on the sofa. You grab the remote control, look at it and point at the television, you watch television. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'food_bread', 'food_ice_cream', 'tea', 'walllamp', 'drawing', 'bills', 'knifeblock', 'orchid', 'bathroom_counter', 'floor', 'keyboard', 'bookshelf', 'envelope', 'computer', 'ceilinglamp', 'iron', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'toy', 'television', 'tray', 'curtain', 'sink', 'bathroom_cabinet', 'table'] Task:Read magazine response: { thoughts : Please sit on the couch and read a magazine, actions : ['[WALK] <home_office>', '[WALK] <newspaper>', '[FIND] <newspaper>', '[GRAB] <newspaper>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <newspaper>', '[LOOKAT] <newspaper>', '[READ] <newspaper>', '[READ] <newspaper>', '[READ] <newspaper>'] } Scene_Objects:['pot', 'tablelamp', 'juice', 'toilet', 'walllamp', 'nail_polish', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'phone', 'desk', 'stovefan', 'plate', 'faucet', 'window', 'mousepad', 'form', 'pillow', 'wall', 'wall_clock', 'oven', 'clothes_gloves', 'tray', 'diary', 'kitchen_counter', 'shoes', 'cupboard', 'door', 'sink'] Task:Wash dishes by hand response:

{ Walking towards sink and look at the leftover plates. Scrape dishes to remove leftover food - use a rubber spatula or paper towel. Fill sink or dishpan with clean, hot water. Then wash and rinse to removing residues. Finally leave it to dry. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['blender', 'band-aids', 'freezer', 'walllamp', 'nail_polish', 'trashcan', 'dough', 'drawing', 'bills', 'cpuscreen', 'bathroom_counter', 'ceiling', 'phone', 'character', 'desk', 'purse', 'alcohol', 'clothes_jacket', 'toaster', 'mat', 'faucet', 'oil', 'couch', 'broom', 'oven', 'photoframe', 'tray', 'kitchen_counter', 'dresser', 'laser_pointer'] Task:Pet cat response: { thoughts : Find a cat in the kitchen and touch it, actions : ['[WALK] <dining_room>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['microwave', 'chair', 'walllamp', 'food_carrot', 'orchid', 'knife', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'food_bacon', 'ceilinglamp', 'mat', 'tvstand', 'stereo', 'mousepad', 'couch', 'wall', 'powersocket', 'toy', 'photoframe', 'mouse', 'controller', 'door', 'table', 'light'] Task:Browse internet response:

{ turn on the computer and browse the internet }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'toilet', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'floor', 'toaster', 'mat', 'faucet', 'shower', 'pillow', 'wall', 'nightstand', 'bench', 'toy', 'coffe_maker', 'television', 'curtain', 'after_shave', 'doorjamb', 'towel_rack', 'kitchen_counter', 'chessboard', 'sink', 'home_office', 'bathroom_cabinet', 'table', 'instrument_violin'] Task:Go to toilet response: { thoughts : Walk to the bathroom. Find the toilet. Lift the top of the toilet. Sit on the toilet., actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[OPEN] <toilet>', '[SIT] <toilet>'] } Scene_Objects:['sponge', 'pot', 'filing_cabinet', 'tablelamp', 'food_ice_cream', 'beer', 'toilet', 'drawing', 'hanger', 'floor', 'bookshelf', 'envelope', 'tvstand', 'shower', 'faucet', 'candle', 'dining_room', 'broom', 'wall', 'toy', 'cup', 'photoframe', 'clothes_gloves', 'light_bulb', 'wooden_spoon', 'curtain', 'doorjamb', 'chessboard', 'dishrack', 'door'] Task:Go to toilet response:

{ I walk to the entrance of the bathroom. I turn to the door. I open the door to the bathroom. I walk inside of the bathroom. I find the toilet inside of the bathroom and walk over to it. I turn and look at the toilet. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'dog', 'freezer', 'orchid', 'drawing', 'wallshelf', 'ceiling', 'character', 'mail', 'clothes_jacket', 'computer', 'mat', 'faucet', 'window', 'closetdrawer', 'nightstand', 'wall_clock', 'oven', 'basket_for_clothes', 'coffe_maker', 'mouse', 'dresser', 'cupboard', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'light', 'scrabble', 'washing_machine'] Task:Wash clothes response: { thoughts : Pick up my dirty clothes, load the washer, add detergent, turn on washer, actions : ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <home_office>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[RUN] <washing_machine>'] } Scene_Objects:['food_pizza', 'food_bread', 'beer', 'freezer', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'food_cake', 'alcohol', 'computer', 'clothes_jacket', 'ceilinglamp', 'tvstand', 'mousepad', 'microphone', 'towel', 'wall', 'powersocket', 'food_food', 'television', 'wine', 'doorjamb', 'mouse', 'pencil', 'door', 'light', 'dishwasher'] Task:Put groceries in Fridge response:

{ Go to kitchen and put groceries in fridge }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'walllamp', 'knifeblock', 'drawing', 'cpuscreen', 'clothes_underwear', 'knife', 'floor', 'ceiling', 'cleaning_solution', 'piano_bench', 'toaster', 'ceilinglamp', 'faucet', 'stereo', 'iron', 'wall', 'oven', 'cutting_board', 'tape', 'check', 'coin', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'bag', 'home_office', 'instrument_violin', 'hands_both'] Task:Wash hands response: { thoughts : Washing hands, actions : ['[WALK] <dining_room>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <cleaning_solution>', '[SQUEEZE] <cleaning_solution>', '[SCRUB] <hands_both>', '[SWITCHON] <faucet>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>'] } Scene_Objects:['chair', 'walllamp', 'orchid', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'stereo', 'tvstand', 'mousepad', 'couch', 'broom', 'wall', 'bed', 'check', 'toilet_paper', 'television', 'ice', 'kettle', 'mouse', 'door', 'sink', 'home_office', 'table'] Task:Browse internet response:

{ I go in my office, sit at my desk turn on the computer, then type on my keyboard and open my web browser. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'juice', 'microwave', 'cat', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'computer', 'clothes_jacket', 'button', 'ceilinglamp', 'mat', 'window', 'couch', 'food_jam', 'wall', 'nightstand', 'cutting_board', 'cup', 'television', 'mouse', 'pencil', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'table', 'vase', 'coffee'] Task:Pet cat response: { thoughts : Walk into bedrrom and to the sofa. Sit on the sofa and touch cat., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['toilet', 'chair', 'walllamp', 'food_butter', 'trashcan', 'orchid', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'towel', 'wall', 'pasta', 'bench', 'cup', 'curtain', 'mouse', 'dresser', 'clothes_dress', 'door', 'table', 'tooth_paste'] Task:Write an email response:

{ enter office, find computer, turn it on, }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'orchid', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'computer', 'clothes_jacket', 'table_cloth', 'ceilinglamp', 'shower', 'window', 'homework', 'mousepad', 'pillow', 'powersocket', 'photoframe', 'coffe_maker', 'doorjamb', 'kettle', 'shoes', 'dresser', 'cupboard', 'laundry_detergent', 'clothes_dress', 'door', 'bag', 'light', 'washing_machine'] Task:Wash clothes response: { thoughts : Go to bedroom and grab dirty pants and take to the washing machine in entrance hall. Put clothes in washing machine and then put in laundry detergent., actions : ['[WALK] <bedroom>', '[WALK] <clothes_pants>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[WALK] <home_office>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>'] } Scene_Objects:['dry_pasta', 'microwave', 'blow_dryer', 'detergent', 'cat', 'drawing', 'desk', 'thread', 'computer', 'button', 'table_cloth', 'ceilinglamp', 'tvstand', 'mousepad', 'broom', 'nightstand', 'oven', 'powersocket', 'box', 'newspaper', 'coffe_maker', 'tray', 'doorjamb', 'mouse', 'conditioner', 'bag', 'napkin', 'table', 'light', 'soap'] Task:Pet cat response:

{ I walk to my cat, and I pet him }