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:['glue', 'tablelamp', 'chair', 'walllamp', 'bathroom', 'trashcan', 'ceilingfan', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'computer', 'laptop', 'balanceball', 'mousepad', 'pillow', 'wall', 'cup', 'bed', 'television', 'razor', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'spoon', 'light', 'vase'] Task:Turn on light response: { thoughts : push any ligth button to turn it on, for example in the living room, actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['pot', 'tablelamp', 'walllamp', 'orchid', 'drawing', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'iron', 'window', 'shower', 'couch', 'pillow', 'food_kiwi', 'wall', 'pasta', 'powersocket', 'bed', 'check', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'controller', 'door', 'table'] Task:Watch TV response:

{ Walk to Living room. Find Television. Walk to sofa. Sit on sofa. Find Remote. Grab remote. Turn to television. Look at television. Switch on 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:['dry_pasta', 'pot', 'food_salt', 'jelly', 'walllamp', 'detergent', 'knife', 'drawing', 'hanger', 'floor', 'dvd_player', 'character', 'desk', 'bedroom', 'plate', 'dish_soap', 'oil', 'wall', 'powersocket', 'bed', 'light_bulb', 'coffe_maker', 'toilet_paper', 'rag', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : Put dishes in the dishwasher and start the dishwasher., actions : ['[RUN] <dining_room>', '[WALK] <bowl>', '[FIND] <bowl>', '[GRAB] <bowl>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <bowl> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[WALK] <dishwasher>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['measuring_cup', 'chair', 'walllamp', 'bathroom', 'milk', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'envelope', 'computer', 'mat', 'ceilinglamp', 'stereo', 'mousepad', 'wall', 'toothbrush_holder', 'food_rice', 'ice', 'after_shave', 'mouse', 'headset', 'dresser', 'door', 'home_office', 'table', 'board_game'] Task:Work response:

{ Walk to home office, walk to desk, sit in chair, turn on computer, look at computer, click mouse and type on keyboard. }

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', 'tea', 'microwave', 'walllamp', 'detergent', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'stovefan', 'toaster', 'faucet', 'stereo', 'bowl', 'food_kiwi', 'wall', 'oven', 'bed', 'coffe_maker', 'food_food', 'drinking_glass', 'food_donut', 'tray', 'after_shave', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher', 'clothes_skirt'] Task:Drink response: { thoughts : First I go into the kitchen, open the cupboard and find a glass.Then I close the cupboard. Then I go to the sink, turn the faucet on fill the glass under the faucet. I turn off the faucet and then I drink., actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <drinking_glass> <sink>', '[GRAB] <drinking_glass>', '[DRINK] <drinking_glass>'] } Scene_Objects:['sponge', 'tablelamp', 'juice', 'microwave', 'toilet', 'chair', 'freezer', 'ground_coffee', 'bathroom', 'knife', 'ceiling', 'bedroom', 'clothes_jacket', 'bookmark', 'toaster', 'faucet', 'iron', 'couch', 'food_peanut_butter', 'dining_room', 'oven', 'cup', 'photoframe', 'newspaper', 'coffe_maker', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'home_office'] Task:Pet cat response:

{ find a cat, touch 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:['food_bread', 'filing_cabinet', 'tablelamp', 'scissors', 'microwave', 'chair', 'freezer', 'food_butter', 'drawing', 'knife', 'cpuscreen', 'floor', 'folder', 'desk', 'keyboard', 'computer', 'mail', 'mat', 'shower', 'mousepad', 'wall', 'nightstand', 'bed', 'ice', 'after_shave', 'doorjamb', 'mouse', 'kitchen_counter', 'food_steak', 'light'] Task:Work response: { thoughts : I work on my HP computer., actions : ['[WALK] <bedroom>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[WALK] <bed>', '[SIT] <bed>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['toilet', 'freezer', 'walllamp', 'food_butter', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'stereo', 'faucet', 'window', 'mousepad', 'pillow', 'wall', 'powersocket', 'bed', 'coffee_table', 'television', 'doorjamb', 'pencil', 'dresser', 'clothes_dress', 'door', 'table', 'dishwasher'] Task:Change TV channel response:

{ Walk to the living room and look at the coffee table. Grab the remote control and turn to the television and point the remote control. Put back the 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:['sheets', 'filing_cabinet', 'measuring_cup', 'chair', 'nail_polish', 'cat', 'drawing', 'hanger', 'floor', 'phone', 'desk', 'keyboard', 'food_bacon', 'table_cloth', 'bookmark', 'stovefan', 'plate', 'shower', 'dish_soap', 'couch', 'wall', 'powersocket', 'basket_for_clothes', 'toilet_paper', 'pencil', 'hair', 'home_office', 'light', 'dishwasher', 'shoe_rack'] 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:['pot', 'microwave', 'nail_polish', 'bathroom', 'cat', 'detergent', 'trashcan', 'milk', 'orchid', 'knife', 'computer', 'food_bacon', 'faucet', 'stereo', 'oil', 'food_noodles', 'microphone', 'dining_room', 'nightstand', 'oven', 'food_cheese', 'novel', 'check', 'coffe_maker', 'food_onion', 'coffee_pot', 'kitchen_counter', 'dresser', 'hairdryer', 'home_office'] Task:Read book response:

{ go to bedroom, sit down, pick up book, read }

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', 'pot', 'measuring_cup', 'microwave', 'chair', 'orchid', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'cleaning_solution', 'keyboard', 'mop_bucket', 'stovefan', 'faucet', 'couch', 'clothes_pants', 'coffe_maker', 'mirror', 'curtain', 'rag', 'coffee_pot', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink', 'dishwasher'] Task:Clean mirror response: { thoughts : Spray the mirror with a cleaner, take a dry rag and wipe the mirror down until its clean., actions : ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[FIND] <rag>', '[GRAB] <rag>', '[POUR] <cleaning_solution> <rag>', '[PUTOBJBACK] <cleaning_solution>', '[WALK] <mirror>', '[WIPE] <mirror>', '[PUTOBJBACK] <rag>'] } Scene_Objects:['filing_cabinet', 'food_bread', 'toilet', 'bathroom', 'milk', 'drawing', 'floor', 'ceiling', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'shower', 'mousepad', 'towel', 'wall', 'bench', 'cup', 'photoframe', 'toothbrush_holder', 'water', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light', 'clothes_skirt', 'soap'] Task:Take shower response:

{ Walk into bathroom. Turn on shower. Take off clothing. Climb into shower. Rinse with water. Soap up body. Rinse off with water. Turn off shower. Climb out of shower. Dry off with towel. }

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', 'detergent', 'food_butter', 'dough', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'purse', 'faucet', 'stereo', 'picture', 'dustpan', 'bowl', 'dining_room', 'wall', 'oven', 'powersocket', 'photoframe', 'wine', 'tray', 'console', 'pencil', 'sink', 'bathroom_cabinet', 'dishwasher', 'hands_both', 'shoe_rack'] Task:Wash hands response: { thoughts : I go to the bathroom, walk to the sink, turn on the faucet and then wash my hands under the water., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>'] } 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:

{ Washing 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:['food_bread', 'blender', 'freezer', 'walllamp', 'nail_polish', 'trashcan', 'knifeblock', 'orchid', 'hanger', 'floor', 'bedroom', 'keyboard', 'computer', 'stereo', 'window', 'oil', 'couch', 'pillow', 'wall', 'cup', 'bed', 'food_donut', 'curtain', 'centerpiece', 'console', 'shoes', 'dresser', 'maindoor', 'home_office', 'light'] Task:Listen to music response: { thoughts : Turn on radio, put on favorite channel, listen to music., actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>', '[FIND] <bed>', '[LIE] <bed>'] } Scene_Objects:['toilet', 'detergent', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'dvd_player', 'bedroom', 'food_cake', 'stovefan', 'mat', 'faucet', 'window', 'wall', 'oven', 'cup', 'photoframe', 'curtain', 'after_shave', 'doorjamb', 'cards', 'shoes', 'food_steak', 'sink', 'bathroom_cabinet', 'light', 'soap', 'hands_both'] Task:Wash hands response:

{ 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:['food_ice_cream', 'toilet', 'freezer', 'trashcan', 'drawing', 'floor', 'phone', 'ceiling', 'character', 'bedroom', 'desk', 'keyboard', 'toaster', 'mat', 'faucet', 'window', 'wall', 'wall_clock', 'powersocket', 'box', 'cup', 'bed', 'video_game_controller', 'television', 'doorjamb', 'console', 'kitchen_counter', 'door', 'light', 'teeth'] Task:Pick up phone response: { thoughts : I walk over to the phone and pick it up., actions : ['[WALK] <phone>', '[GRAB] <phone>'] } Scene_Objects:['sheets', 'pot', 'shoe_rack', 'toilet', 'chair', 'band-aids', 'freezer', 'walllamp', 'cat', 'trashcan', 'folder', 'bookshelf', 'deck_of_cards', 'shower', 'mousepad', 'food_kiwi', 'wall', 'powersocket', 'cup', 'bed', 'clothes_gloves', 'keys', 'television', 'kitchen_counter', 'dishrack', 'controller', 'napkin', 'light', 'soap', 'creditcard'] Task:Pet cat response:

{ I go to the living room then go to the cat and touch 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:['measuring_cup', 'microwave', 'toilet', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'phone', 'food_cake', 'computer', 'ceilinglamp', 'shoe-shine_kit', 'iron', 'stereo', 'electric_shaver', 'homework', 'balanceball', 'picture', 'window', 'dining_room', 'powersocket', 'cup', 'photoframe', 'mirror', 'tray', 'pencil', 'shoes', 'conditioner', 'sink', 'creditcard'] Task:Shave response: { thoughts : Pick up razor. Push the button to turn it on. Move it in a linear motion against the beard growth. Make sure to get the bottom of your chin, your cheeks, and mustache area., actions : ['[WALK] <bathroom>', '[WALK] <electric_shaver>', '[FIND] <electric_shaver>', '[GRAB] <electric_shaver>', '[FIND] <mirror>', '[TURNTO] <mirror>', '[SWITCHON] <electric_shaver>', '[SWITCHOFF] <electric_shaver>', '[PUTOBJBACK] <electric_shaver>'] } Scene_Objects:['sheets', 'spectacles', 'food_salt', 'freezer', 'cpuscreen', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'purse', 'computer', 'ceilinglamp', 'window', 'mousepad', 'food_noodles', 'wall', 'powersocket', 'clothes_gloves', 'food_food', 'toilet_paper', 'television', 'check', 'tray', 'doorjamb', 'cards', 'mouse', 'door', 'light', 'table'] Task:Put groceries in Fridge response:

{ Open the fridge, put the groceries in the fridge and close 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:['mop', 'microwave', 'bathroom', 'detergent', 'wallshelf', 'clothes_underwear', 'hanger', 'ceiling', 'bookshelf', 'tvstand', 'faucet', 'deck_of_cards', 'window', 'clothes_socks', 'clothes_pants', 'cup', 'standingmirror', 'photoframe', 'check', 'tray', 'kitchen_counter', 'hair', 'laundry_detergent', 'door', 'bathroom_cabinet', 'tooth_paste', 'clothes_shirt', 'washing_machine', 'coffee', 'shoe_rack'] Task:Wash clothes response: { thoughts : I grab the basket for clothes from the bedroom. I carry it and walk to the washing machine. I open the washing machine. I grab the dirty clothes. I put the clothes in the washing machine. I grab the laundry detergent and put it in the washing machine. I close the washing machine. I switch on the washing machine., actions : ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <washing_machine>', '[DROP] <basket_for_clothes>', '[OPEN] <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTBACK] <clothes_socks> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[GRAB] <laundry_detergent>', '[PUTOBJBACK] <laundry_detergent>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['pot', 'beer', 'microwave', 'jelly', 'freezer', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'tea_bag', 'keyboard', 'purse', 'computer', 'iron', 'window', 'mousepad', 'oil', 'wall', 'powersocket', 'bed', 'keys', 'mouthwash', 'wine', 'doorjamb', 'mouse', 'cupboard', 'door', 'sink', 'light'] Task:Turn on light response:

{ walk in kitchen. switch on light. walk in living room. switch on light.walk in entrance hall. switch on 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:['dry_pasta', 'pot', 'filing_cabinet', 'beer', 'chair', 'cpuscreen', 'bathroom_counter', 'phone', 'desk', 'cleaning_solution', 'bookmark', 'iron', 'mousepad', 'couch', 'dustpan', 'food_jam', 'tape', 'television', 'wooden_spoon', 'curtain', 'rag', 'doorjamb', 'hairbrush', 'cupboard', 'door', 'bathroom_cabinet', 'table', 'vase', 'colander', 'teeth'] Task:Clean mirror response: { thoughts : Spray the mirror with a cleaner, take a dry rag and wipe the mirror down until its clean., actions : ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[FIND] <rag>', '[GRAB] <rag>', '[POUR] <cleaning_solution> <rag>', '[PUTOBJBACK] <cleaning_solution>', '[WALK] <mirror>', '[WIPE] <mirror>', '[PUTOBJBACK] <rag>'] } Scene_Objects:['food_ice_cream', 'microwave', 'freezer', 'trashcan', 'toothbrush', 'orchid', 'hanger', 'desk', 'keyboard', 'bookmark', 'shoe-shine_kit', 'iron', 'tvstand', 'plate', 'mousepad', 'microphone', 'wall', 'bench', 'toilet_paper', 'television', 'toothbrush_holder', 'ice', 'shoes', 'chessboard', 'hairbrush', 'cupboard', 'bathroom_cabinet', 'tooth_paste', 'teeth', 'creditcard'] Task:Wash teeth response:

{ 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 }

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', 'glue', 'tablelamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'purse', 'computer', 'clothes_jacket', 'toaster', 'stereo', 'mousepad', 'closetdrawer', 'couch', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'bed', 'novel', 'mouse', 'shoes', 'dresser', 'clothes_dress', 'light', 'table'] Task:Get ready for day response: { thoughts : Grab shoes, purse etc and head out the door!, actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[PUTON] <clothes_dress>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>', '[FIND] <purse>', '[GRAB] <purse>', '[CLOSE] <dresser>', '[WALK] <home_office>'] } Scene_Objects:['glue', 'fork', 'food_pizza', 'tablelamp', 'crayon', 'measuring_cup', 'dough', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'food_cake', 'toaster', 'mat', 'faucet', 'shower', 'wall', 'powersocket', 'bench', 'cup', 'colander', 'mouse', 'hairbrush', 'sink', 'spoon', 'bathroom_cabinet', 'light', 'soap', 'hands_both'] Task:Wash hands response:

{ go to the bathroom and wash your 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:['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: { thoughts : 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., 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>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['spectacles', 'water_glass', 'glue', 'walllamp', 'detergent', 'food_carrot', 'toothbrush', 'drawing', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'computer', 'ceilinglamp', 'tvstand', 'window', 'couch', 'clothes_pants', 'form', 'pillow', 'wall', 'nightstand', 'box', 'curtain', 'pencil', 'headset', 'dresser', 'table', 'board_game', 'shoe_rack'] Task:Relax on sofa response:

{ Drink a glass of water in 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', 'microwave', 'toilet', 'chair', 'walllamp', 'nail_polish', 'trashcan', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'toaster', 'stovefan', 'faucet', 'towel', 'pillow', 'wall', 'wall_clock', 'bed', 'check', 'television', 'doorjamb', 'kitchen_counter', 'dresser', 'controller', 'sink', 'bathroom_cabinet', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : Cleaning hands, actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>'] } Scene_Objects:['sheets', 'tablelamp', 'blender', 'freezer', 'walllamp', 'dough', 'orchid', 'drawing', 'floor', 'ceiling', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'window', 'picture', 'couch', 'pillow', 'bowl', 'wall', 'powersocket', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'dishrack', 'door', 'sink', 'table'] Task:Watch TV response:

{ Turn on the TV, sit on the couch, find a show, and watch 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:['pot', 'juice', 'microwave', 'freezer', 'blow_dryer', 'ground_coffee', 'cat', 'floor', 'legs_both', 'face', 'toaster', 'laptop', 'homework', 'closetdrawer', 'towel', 'feet_both', 'arms_both', 'basket_for_clothes', 'newspaper', 'photoframe', 'coffe_maker', 'mouthwash', 'centerpiece', 'doorjamb', 'headset', 'dresser', 'cupboard', 'napkin', 'soap', 'clothes_shirt'] Task:Try yourself off response: { thoughts : After your shower, go into your bedroom and use a towel to dry water off of yourself before dressing., actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[FIND] <towel>', '[GRAB] <towel>', '[CLOSE] <dresser>', '[FIND] <face>', '[WIPE] <face>', '[FIND] <arms_both>', '[WIPE] <arms_both>', '[FIND] <legs_both>', '[WIPE] <legs_both>', '[FIND] <feet_both>', '[WIPE] <feet_both>', '[FIND] <basket_for_clothes>', '[PUTBACK] <towel> <basket_for_clothes>'] } Scene_Objects:['pot', 'chair', 'walllamp', 'ground_coffee', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'plate', 'homework', 'mousepad', 'dining_room', 'wall', 'bench', 'newspaper', 'novel', 'check', 'mouse', 'kitchen_counter', 'hair', 'door', 'sink', 'home_office', 'table'] Task:Browse internet response:

{ I sit at my computer desk and open the 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', 'toilet', 'chair', 'freezer', 'walllamp', 'ceiling', 'bedroom', 'keyboard', 'toaster', 'ceilinglamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'clothes_pants', 'food_orange', 'nightstand', 'bench', 'photoframe', 'bed', 'food_food', 'tray', 'mouse', 'kitchen_counter', 'dresser', 'laundry_detergent', 'bathtub', 'bathroom_cabinet', 'table', 'washing_machine'] Task:Wash clothes response: { thoughts : Walk into laundry room. Open washing machine door. Put dirty clothes into washing machine. Measure laundry detergent and place into washing machine. Turn dial to appropriate wash setting. Power on., actions : ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[CLOSE] <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[OPEN] <washing_machine>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['fork', 'pot', 'microwave', 'ground_coffee', 'walllamp', 'detergent', 'trashcan', 'knifeblock', 'floor', 'ceiling', 'keyboard', 'toaster', 'stovefan', 'faucet', 'wall', 'pasta', 'oven', 'coffe_maker', 'food_food', 'check', 'coffee_filter', 'television', 'water', 'tray', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'clothes_scarf', 'dishwasher'] Task:Make coffee response:

{ I walk to the kitchen and find the coffee machine. I open the coffee machine and pour a filter in it. I open the cupboard and grab ground coffee. I put ground coffee in the filter and water in the coffee machine. I close the coffee machine. I switch on the coffee machine and wait }

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', 'detergent', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'remote_control', 'button', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'stereo', 'window', 'clothes_socks', 'couch', 'wall', 'basket_for_clothes', 'light_bulb', 'television', 'razor', 'curtain', 'food_onion', 'towel_rack', 'coffee_pot', 'pencil', 'kitchen_counter', 'bag', 'table'] Task:Watch TV response: { thoughts : turn on the tv, actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TOUCH] <remote_control>'] } Scene_Objects:['scissors', 'blender', 'freezer', 'walllamp', 'trashcan', 'orchid', 'knife', 'bathroom_counter', 'shampoo', 'character', 'desk', 'folder', 'keyboard', 'stovefan', 'mat', 'picture', 'window', 'food_noodles', 'bench', 'toothbrush_holder', 'food_donut', 'after_shave', 'doorjamb', 'cards', 'kitchen_counter', 'vacuum_cleaner', 'dishrack', 'door', 'home_office', 'bathroom_cabinet'] Task:Pick up phone response:

{ I walk to the home office. I find the telephone. I pick up the telephone handset. }

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', 'microwave', 'toilet', 'chair', 'dog', 'cpuscreen', 'keyboard', 'ceilinglamp', 'plate', 'laptop', 'faucet', 'window', 'stereo', 'oil', 'food_noodles', 'mousepad', 'dining_room', 'nightstand', 'food_food', 'check', 'wine', 'curtain', 'after_shave', 'comb', 'dresser', 'napkin', 'home_office', 'table', 'bathroom_cabinet', 'light'] Task:Listen to music response: { thoughts : I reach out arm. I put hand on radio. I turn on radio. I pick a station., actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[TOUCH] <stereo>', '[TURNTO] <stereo>'] } Scene_Objects:['fork', 'microwave', 'chair', 'detergent', 'trashcan', 'knifeblock', 'floor', 'ceiling', 'character', 'bookshelf', 'purse', 'computer', 'toaster', 'mat', 'tvstand', 'clothes_socks', 'food_peanut_butter', 'microphone', 'food_jam', 'pillow', 'wall', 'powersocket', 'after_shave', 'doorjamb', 'cd', 'pajamas', 'laundry_detergent', 'door', 'light', 'tooth_paste'] Task:Turn on light response:

{ Coming home 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:['toilet', 'chair', 'freezer', 'walllamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'window', 'mousepad', 'wall', 'powersocket', 'box', 'coffe_maker', 'television', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'bathroom_cabinet', 'table'] 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:['fork', 'pot', 'microwave', 'walllamp', 'trashcan', 'knife', 'drawing', 'floor', 'computer', 'toaster', 'mat', 'plate', 'faucet', 'ceilinglamp', 'stovefan', 'dish_soap', 'oil', 'wall', 'powersocket', 'tape', 'coffe_maker', 'television', 'drinking_glass', 'rag', 'shaving_cream', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher', 'clothes_skirt'] Task:Wash dishes with dishwasher response:

{ Walk to the kitchen and turn to the dishwasher, put the knife, glass, fork and plate into the dishwasher. Turn on the 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:['scissors', 'tablelamp', 'chair', 'freezer', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'newspaper', 'television', 'doorjamb', 'dresser', 'soap', 'instrument_violin'] Task:Watch TV response: { thoughts : I sit on my couch and watch TV in my living room, actions : ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[WATCH] <television>', '[WATCH] <television>'] } Scene_Objects:['toilet', 'chair', 'walllamp', 'knifeblock', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'alcohol', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'iron', 'faucet', 'mousepad', 'bowl', 'wall', 'nightstand', 'oven', 'mouse', 'cupboard', 'door', 'clothes_scarf', 'bathroom_cabinet', 'table', 'instrument_guitar'] Task:Work response:

{ For doing homework walk to home office. Walk to computer. Switch on Computer. Sit in a chair and do homework in 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:['food_bread', 'food_salt', 'beer', 'walllamp', 'drawing', 'orchid', 'knifeblock', 'clothes_underwear', 'floor', 'folder', 'man', 'computer', 'toaster', 'ceilinglamp', 'stereo', 'window', 'homework', 'mousepad', 'couch', 'microphone', 'pillow', 'wall', 'nightstand', 'keys', 'food_food', 'wooden_spoon', 'curtain', 'doorjamb', 'hair', 'table'] Task:Have conversation with boyfriend response: { thoughts : Sit on sofa, talk, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <man>', '[GREET] <man>'] } Scene_Objects:['microwave', 'chair', 'freezer', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'deck_of_cards', 'electric_shaver', 'mousepad', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'newspaper', 'bed', 'food_food', 'wine', 'doorjamb', 'cards', 'mouse', 'shoes', 'dresser', 'door', 'light', 'dirt'] Task:Put groceries in Fridge response:

{ walk to kitchen, walk to fridge, look at bags, grab groceries, 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:['microwave', 'toilet', 'walllamp', 'bathroom', 'detergent', 'trashcan', 'woman', 'knifeblock', 'needle', 'cpuscreen', 'desk', 'man', 'keyboard', 'bedroom', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'nightstand', 'oven', 'cup', 'food_food', 'check', 'doorjamb', 'mouse', 'kitchen_counter', 'bathtub', 'bathroom_cabinet', 'table', 'light'] 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:['tablelamp', 'freezer', 'walllamp', 'ground_coffee', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'phone', 'ceiling', 'character', 'bookshelf', 'food_cake', 'mat', 'tvstand', 'shoe-shine_kit', 'homework', 'oil', 'couch', 'food_peanut_butter', 'pillow', 'dining_room', 'wall', 'bench', 'oven', 'powersocket', 'toilet_paper', 'kitchen_counter', 'door', 'tooth_paste'] Task:Pick up phone response:

{ walk over and 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:['glue', 'filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'dog', 'freezer', 'knife', 'floor', 'ceiling', 'folder', 'stamp', 'brush', 'mat', 'ceilinglamp', 'shower', 'faucet', 'toaster', 'pillow', 'bowl', 'food_kiwi', 'wall', 'powersocket', 'toilet_paper', 'mouthwash', 'doorjamb', 'door', 'home_office', 'light', 'table'] Task:Turn light off response: { thoughts : Put the light switch into the down, or off, position., actions : ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHOFF] <light>'] } Scene_Objects:['fork', 'glue', 'board_game', 'toilet', 'bathroom', 'dough', 'toothbrush', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'mop_bucket', 'mat', 'faucet', 'window', 'wall', 'photoframe', 'food_food', 'toothbrush_holder', 'razor', 'tray', 'after_shave', 'doorjamb', 'vacuum_cleaner', 'conditioner', 'sink', 'napkin', 'bathroom_cabinet', 'soap', 'tooth_paste'] Task:Wash teeth response:

{ 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. }

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', 'filing_cabinet', 'food_pizza', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'cleaning_solution', 'mail', 'brush', 'toaster', 'tvstand', 'balanceball', 'window', 'food_noodles', 'mousepad', 'food_peanut_butter', 'clothes_hat', 'dining_room', 'pasta', 'bench', 'photoframe', 'oven_mitts', 'ice', 'rag', 'dresser', 'cupboard', 'food_steak', 'maindoor', 'table'] Task:Clean mirror response: { thoughts : GET CLEANING CLOTH, SPRAY CLEANER ON CLOTH, CLEAN MIRROR, actions : ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[FIND] <rag>', '[GRAB] <rag>', '[POUR] <cleaning_solution> <rag>', '[PUTOBJBACK] <cleaning_solution>', '[WALK] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[PUTOBJBACK] <rag>'] } Scene_Objects:['sheets', 'filing_cabinet', 'tablelamp', 'walllamp', 'trashcan', 'dough', 'toothbrush', 'floor', 'dvd_player', 'bedroom', 'stovefan', 'mat', 'tvstand', 'window', 'food_noodles', 'dining_room', 'nightstand', 'powersocket', 'oven', 'cutting_board', 'cup', 'light_bulb', 'coffe_maker', 'mouthwash', 'oven_mitts', 'doorjamb', 'diary', 'bag', 'home_office', 'scrabble'] Task:Pick up phone response:

{ go to living room, find phone, pick up 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:['freezer', 'walllamp', 'ground_coffee', 'knifeblock', 'cpuscreen', 'longboard', 'floor', 'phone', 'bedroom', 'toaster', 'faucet', 'pillow', 'wall', 'bed', 'novel', 'water', 'tray', 'centerpiece', 'cards', 'kitchen_counter', 'shoes', 'dresser', 'cupboard', 'conditioner', 'sink', 'bag', 'napkin', 'table', 'dishwasher', 'board_game'] Task:Drink response: { thoughts : Walk to kitchen, grab a glass, walk to sink, turn on tap and pour water into glass, drink from glass., actions : ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <sink>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[DRINK] <cup>'] } Scene_Objects:['pot', 'jelly', 'freezer', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'food_chicken', 'desk', 'keyboard', 'computer', 'food_bacon', 'toaster', 'ceilinglamp', 'stovefan', 'faucet', 'mousepad', 'oil', 'wall', 'powersocket', 'oven', 'food_food', 'tray', 'doorjamb', 'coffee_pot', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light'] Task:Cook some food response:

{ I walk in the kitchen, I open the fridge and remove the Chicken. I grab frying fan and put it on stove. I put chicken in the frying pan and I cook food. }

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', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'floor_lamp', 'mousepad', 'couch', 'dining_room', 'wall', 'nightstand', 'powersocket', 'bed', 'coffe_maker', 'doorjamb', 'cd', 'door', 'bathtub', 'home_office', 'light'] Task:Turn on light response: { thoughts : walk to wall, find light switch, turn on lights, actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[PLUGIN] <light>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[WALK] <bedroom>', '[WALK] <light>', '[SWITCHON] <light>'] } Scene_Objects:['sheets', 'pot', 'dry_pasta', 'bathroom', 'toothbrush', 'drawing', 'knifeblock', 'phone', 'character', 'clothes_jacket', 'piano_bench', 'mat', 'shoe-shine_kit', 'stereo', 'window', 'oil', 'nightstand', 'cup', 'clothes_gloves', 'check', 'wine', 'tray', 'console', 'pencil', 'dresser', 'hair', 'door', 'clothes_skirt', 'dishwasher', 'clothes_shirt'] Task:Pet cat response:

{ Pet 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', 'chair', 'freezer', 'food_butter', 'drawing', 'bills', 'cpuscreen', 'longboard', 'floor', 'bedroom', 'desk', 'bookshelf', 'button', 'bookmark', 'toaster', 'ceilinglamp', 'deck_of_cards', 'iron', 'tvstand', 'pillow', 'pasta', 'bench', 'powersocket', 'bed', 'coffe_maker', 'television', 'ice', 'mouse', 'dresser', 'controller'] Task:Pick up phone response: { thoughts : walk into living room, look at the phone when it ringing, grab the phone or pickup the phone, actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>'] } Scene_Objects:['walllamp', 'toothbrush', 'drawing', 'orchid', 'floor', 'ceiling', 'remote_control', 'clothes_jacket', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'oven', 'box', 'basket_for_clothes', 'novel', 'check', 'television', 'tray', 'curtain', 'doorjamb', 'door', 'table', 'clothes_skirt', 'creditcard'] Task:Change TV channel response:

{ Walk to living room. Walk to and sit at the sofa. Grab remote control and switch on 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:['tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'pillow', 'wall', 'nightstand', 'photoframe', 'wine', 'doorjamb', 'mouse', 'dresser', 'napkin', 'bathroom_cabinet', 'light'] Task:Clean response: { thoughts : Wipe down computer desk and monitor, actions : ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <desk>', '[FIND] <computer>', '[WIPE] <computer>', '[WIPE] <desk>', '[PUTOBJBACK] <rag>'] } Scene_Objects:['microwave', 'walllamp', 'trashcan', 'drawing', 'floor', 'character', 'toaster', 'plate', 'tvstand', 'foundation', 'dish_soap', 'tooth_paste', 'wall', 'cup', 'coffe_maker', 'food_food', 'food_onion', 'centerpiece', 'cards', 'kettle', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'door', 'sink', 'light', 'dishwasher', 'board_game', 'clothes_shirt', 'creditcard'] Task:Wash dishes with dishwasher response:

{ Wash a plate using the dishwasher 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:['dry_pasta', 'sheets', 'pot', 'freezer', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mail', 'tvstand', 'stereo', 'window', 'mousepad', 'clothes_socks', 'wall', 'nightstand', 'powersocket', 'pasta', 'oven', 'light_bulb', 'coffe_maker', 'food_rice', 'doorjamb', 'shaving_cream', 'mouse', 'kitchen_counter', 'door', 'light'] Task:Turn light off response: { thoughts : Put the light switch into the down, or off, position., actions : ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHOFF] <light>'] } Scene_Objects:['walllamp', 'trashcan', 'toothbrush', 'drawing', 'orchid', 'needle', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'stamp', 'bookshelf', 'remote_control', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'wall', 'powersocket', 'television', 'food_rice', 'doorjamb', 'pencil', 'chessboard', 'door', 'hairdryer', 'bathroom_cabinet', 'table', 'scrabble'] Task:Change TV channel response:

{ I go to the livingroom. The TV is on. I pick up the remote and press the next channel button. I look at the television, and see that the channel has changed. }

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', 'chair', 'jelly', 'trashcan', 'toothbrush', 'orchid', 'cpuscreen', 'character', 'bookshelf', 'button', 'mat', 'deck_of_cards', 'faucet', 'shower', 'pillow', 'powersocket', 'bench', 'photoframe', 'bed', 'novel', 'coin', 'kitchen_counter', 'headset', 'chessboard', 'comb', 'dresser', 'table', 'coffee', 'creditcard'] Task:Pick up phone response: { thoughts : Walk to the entrance hall. Find the telephone. Grab the telephone., actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[WALK] <phone>', '[GRAB] <phone>'] } Scene_Objects:['pot', 'filing_cabinet', 'chair', 'jelly', 'trashcan', 'toothbrush', 'orchid', 'cpuscreen', 'character', 'bookshelf', 'button', 'mat', 'deck_of_cards', 'faucet', 'shower', 'pillow', 'powersocket', 'bench', 'photoframe', 'bed', 'novel', 'coin', 'kitchen_counter', 'headset', 'chessboard', 'comb', 'dresser', 'table', 'coffee', 'creditcard'] Task:Pick up phone response:

{ Walk to the entrance hall. Find the telephone. Grab the telephone. }

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', 'tablelamp', 'toilet', 'jelly', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'television', 'coffee_filter', 'curtain', 'doorjamb', 'centerpiece', 'door', 'table'] Task:Watch TV response: { thoughts : I sit down on sofa, get the remote, turn on tv, change channel to show I want to watch, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['freezer', 'cat', 'milk', 'cpuscreen', 'food_egg', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'mousepad', 'towel', 'wall', 'powersocket', 'oven', 'food_food', 'coffe_maker', 'coin', 'doorjamb', 'mouse', 'headset', 'shoes', 'pajamas', 'door', 'light', 'colander', 'coffee'] Task:Put groceries in Fridge response:

{ I walk to the kitchen, open the fridge and put the groceries in the fridge. Then 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:['tablelamp', 'food_salt', 'microwave', 'jelly', 'detergent', 'food_carrot', 'toothbrush', 'needle', 'hanger', 'floor', 'phone', 'shampoo', 'character', 'tvstand', 'iron', 'balanceball', 'stereo', 'mousepad', 'food_jam', 'pillow', 'nightstand', 'toothbrush_holder', 'diary', 'console', 'shaving_cream', 'kitchen_counter', 'sink', 'light', 'dishwasher', 'vase'] Task:Listen to music response: { thoughts : Find the playback device you want to listen to. turn on. press play. enjoyu music., actions : ['[WALK] <bedroom>', '[WALK] <cd_player>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>'] } Scene_Objects:['pot', 'food_ice_cream', 'freezer', 'bathroom', 'knifeblock', 'hanger', 'character', 'desk', 'bedroom', 'folder', 'toaster', 'mat', 'laptop', 'stereo', 'foundation', 'homework', 'bed', 'newspaper', 'television', 'water', 'wine', 'tray', 'kitchen_counter', 'chessboard', 'laundry_detergent', 'food_steak', 'bag', 'home_office', 'light', 'soap'] Task:Wash hands response:

{ put soap on hands, scrub it and rinse with water }

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', 'trashcan', 'bathroom_counter', 'floor', 'phone', 'keyboard', 'computer', 'clothes_jacket', 'table_cloth', 'mat', 'ceilinglamp', 'faucet', 'shower', 'towel', 'dining_room', 'wall', 'powersocket', 'bed', 'check', 'wooden_spoon', 'cards', 'mouse', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'table', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : Go to the bathroom. turn on the water in the sink. apply soap to hands. rub hands together. rinse hands with water. turn off the water., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[WIPE] <hands_both>'] } Scene_Objects:['dry_pasta', 'food_pizza', 'scissors', 'band-aids', 'nail_polish', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'dvd_player', 'bookshelf', 'thread', 'computer', 'button', 'stereo', 'window', 'clothes_socks', 'couch', 'food_peanut_butter', 'dining_room', 'toilet_paper', 'tray', 'mouse', 'dishrack', 'comb', 'bag', 'home_office', 'clothes_shirt', 'shoe_rack'] Task:Pick up phone response:

{ Enter living room. Walk to telephone. Pick up from hook. }

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', 'food_bread', 'microwave', 'walllamp', 'ceilingfan', 'food_butter', 'drawing', 'bills', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'food_orange', 'wall', 'bench', 'photoframe', 'keys', 'check', 'food_food', 'television', 'curtain', 'table'] Task:Change TV channel response: { thoughts : Go to the living room, Switch on the television. Find the remote and press the change channel button, change the channel, actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[FIND] <button>', '[TOUCH] <button>'] } Scene_Objects:['glue', 'tablelamp', 'tea', 'toilet', 'walllamp', 'drawing', 'orchid', 'floor', 'desk', 'bedroom', 'computer', 'ceilinglamp', 'tvstand', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'food_cheese', 'bed', 'food_donut', 'curtain', 'food_onion', 'mouse', 'pajamas', 'controller', 'table', 'dishwasher', 'light', 'board_game'] Task:Relax on sofa response:

{ lie in the sofa, 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:['food_pizza', 'microwave', 'toilet', 'jelly', 'freezer', 'band-aids', 'drawing', 'knifeblock', 'clothes_underwear', 'kitchen_cabinet', 'floor', 'ceiling', 'toaster', 'mat', 'faucet', 'shower', 'wall', 'nightstand', 'powersocket', 'cup', 'basket_for_clothes', 'photoframe', 'food_food', 'water', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light'] Task:Get drink response: { thoughts : I go to the fridge and open the door. I look for the water pitcher, and take it out, making sure to close the fridge door behind me. Then I take a pint glass out of the upper cabinet over the sink and use the water pitcher to pour a full glass of water. Then I return the pitcher to the fridge and shut the door again, and take my glass of water out of the kitche., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <kitchen_cabinet>', '[WALK] <freezer>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[OPEN] <freezer>'] } Scene_Objects:['filing_cabinet', 'crayon', 'toilet', 'chair', 'walllamp', 'bathroom', 'food_butter', 'drawing', 'orchid', 'hanger', 'floor', 'desk', 'tea_bag', 'computer', 'stovefan', 'ceilinglamp', 'shower', 'window', 'couch', 'candle', 'food_orange', 'pillow', 'wall', 'cup', 'bed', 'curtain', 'kettle', 'pencil', 'pajamas', 'table'] Task:Relax on sofa response:

{ Walk to living room. Sit on sofa. Lie down 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:['sheets', 'tablelamp', 'freezer', 'knifeblock', 'knife', 'bathroom_counter', 'shampoo', 'ceiling', 'keyboard', 'stovefan', 'mat', 'stereo', 'clothes_socks', 'oil', 'nightstand', 'powersocket', 'toy', 'novel', 'food_food', 'coffe_maker', 'rag', 'kettle', 'shoes', 'cupboard', 'hair', 'controller', 'door', 'instrument_guitar', 'table', 'light'] Task:Listen to music response: { thoughts : walk into living room, walk to stereo, turn on stereo, listen to music, actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['crayon', 'mop', 'chair', 'freezer', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'alcohol', 'ceilinglamp', 'mat', 'faucet', 'mousepad', 'clothes_hat', 'pillow', 'wall', 'bed', 'newspaper', 'food_food', 'coffee_filter', 'mouse', 'pencil', 'door', 'sink', 'table'] Task:Browse internet response:

{ Go to home office 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:['tablelamp', 'measuring_cup', 'toilet', 'chair', 'ground_coffee', 'bathroom', 'dough', 'wallshelf', 'phone', 'character', 'keyboard', 'computer', 'ceilinglamp', 'deck_of_cards', 'stereo', 'mousepad', 'couch', 'powersocket', 'cutting_board', 'bed', 'food_food', 'food_rice', 'tray', 'wooden_spoon', 'pencil', 'headset', 'cupboard', 'laundry_detergent', 'sink', 'dishwasher'] Task:Pet cat response: { thoughts : find the cat, go near the cat and pet the cat, actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['food_pizza', 'tablelamp', 'dog', 'cat', 'drawing', 'food_egg', 'floor', 'phone', 'piano_bench', 'mat', 'mousepad', 'oil', 'food_jam', 'pillow', 'wall_clock', 'photoframe', 'coffe_maker', 'food_donut', 'food_rice', 'tray', 'after_shave', 'kitchen_counter', 'clothes_dress', 'door', 'sink', 'bag', 'bathroom_cabinet', 'table', 'dishwasher', 'creditcard'] Task:Pick up phone response:

{ walk to living room , find phone ,pick up phone 3 }

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', 'microwave', 'walllamp', 'knifeblock', 'food_egg', 'floor', 'ceiling', 'desk', 'bedroom', 'ceilinglamp', 'plate', 'faucet', 'window', 'dish_soap', 'mousepad', 'bowl', 'wall', 'oven', 'powersocket', 'check', 'mouthwash', 'after_shave', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'sink', 'bathtub', 'dishwasher'] Task:Wash dishes by hand response: { thoughts : I go to the kitchen and turn on the faucet. I get dish soap and put it into the sink. I grab a sponge and a bowl and start cleaning it. I put the bowl into the dishrack. I find a plate and clean it as well. I put it into the dishrack, turn off the faucet and put the sponge back., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <bowl>', '[GRAB] <bowl>', '[POUR] <dish_soap> <sink>', '[PUTOBJBACK] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <bowl>', '[SCRUB] <bowl>', '[RINSE] <bowl>', '[FIND] <dishrack>', '[PUTBACK] <bowl> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[SWITCHOFF] <faucet>', '[PUTOBJBACK] <sponge>'] } Scene_Objects:['dry_pasta', 'toilet', 'nail_polish', 'detergent', 'cat', 'trashcan', 'milk', 'knifeblock', 'phone', 'ceiling', 'desk', 'keyboard', 'mousepad', 'couch', 'pillow', 'bench', 'oven', 'cup', 'bed', 'light_bulb', 'food_food', 'lighter', 'kitchen_counter', 'hairbrush', 'dresser', 'laundry_detergent', 'table', 'clothes_skirt', 'tooth_paste', 'dirt'] Task:Pet cat response:

{ Petting a cat may sound simple.Letting the Cat Come to You.Extend a hand or finger and allow the cat a chance to touch her nose to you. When a cat bumps her head into your hand, it's a signal she wants attention.Focusing on Areas with Scent Glands. Feed with food. }

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', 'toilet', 'walllamp', 'detergent', 'food_carrot', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'bedroom', 'keyboard', 'bookshelf', 'mat', 'mousepad', 'dining_room', 'wall', 'nightstand', 'bench', 'basket_for_clothes', 'bed', 'photoframe', 'coffe_maker', 'food_food', 'wooden_spoon', 'mouse', 'dresser', 'sink', 'dishwasher'] 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:['sheets', 'water_glass', 'pot', 'spectacles', 'chair', 'freezer', 'walllamp', 'knifeblock', 'cpuscreen', 'ceiling', 'character', 'stovefan', 'mat', 'faucet', 'food_orange', 'wall', 'oven', 'cutting_board', 'food_food', 'water', 'tray', 'food_onion', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'instrument_guitar', 'home_office'] Task:Drink response:

{ I go to the kitchen, take a glass from the cupboard, fill with water and 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:['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:['dry_pasta', 'pot', 'food_pizza', 'filing_cabinet', 'tablelamp', 'beer', 'chair', 'freezer', 'blow_dryer', 'bathroom', 'cat', 'cpuscreen', 'phone', 'character', 'food_cake', 'computer', 'piano_bench', 'brush', 'clothes_pants', 'dining_room', 'nightstand', 'cutting_board', 'toilet_paper', 'coffe_maker', 'check', 'curtain', 'kitchen_counter', 'table', 'scrabble', 'creditcard'] Task:Pet cat response:

{ Every time this animal is seen, you must approach it and show compassion for it by petting it in a gentle manner. }

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', '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: { thoughts : 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., actions : ['[WALK] <bathroom>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['pot', 'tablelamp', 'blender', 'crayon', 'microwave', 'toilet', 'walllamp', 'milk', 'drawing', 'bathroom_counter', 'phone', 'desk', 'envelope', 'table_cloth', 'ceilinglamp', 'plate', 'faucet', 'picture', 'couch', 'clothes_pants', 'powersocket', 'bench', 'newspaper', 'tray', 'rag', 'kitchen_counter', 'laundry_detergent', 'soap', 'scrabble', 'washing_machine'] Task:Wash clothes response:

{ Walk to bathroom. Open washing maschine. Grab pants and put it into washing maschine. Pour laundry detergent into washing machine and close the washing maschine. Plug in 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:['filing_cabinet', 'toilet', 'walllamp', 'trashcan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'character', 'bedroom', 'desk', 'bookshelf', 'computer', 'mat', 'tvstand', 'window', 'pillow', 'wall', 'powersocket', 'tray', 'towel_rack', 'mouse', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'bathtub', 'light', 'teeth', 'shoe_rack'] Task:Go to toilet response: { thoughts : walk to bathroom , run to toilet, actions : ['[WALK] <bathroom>', '[RUN] <toilet>'] } 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:

{ Find a cat in the kitchen and touch 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:['spectacles', 'sponge', 'food_bread', 'blender', 'chair', 'walllamp', 'orchid', 'knife', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mat', 'tvstand', 'window', 'mousepad', 'clothes_socks', 'wall', 'oven', 'cup', 'television', 'mouse', 'cupboard', 'door', 'home_office', 'table'] Task:Browse internet response: { thoughts : go to the office, turn computer on, open an browser or any application to open any website., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <computer>'] } Scene_Objects:['food_salt', 'tea', 'microwave', 'freezer', 'ground_coffee', 'walllamp', 'bathroom', 'trashcan', 'floor', 'ceiling', 'mop_bucket', 'toaster', 'picture', 'electric_shaver', 'pillow', 'wall', 'coffe_maker', 'food_food', 'coffee_filter', 'oven_mitts', 'water', 'ice', 'coffee_pot', 'kitchen_counter', 'cd', 'dishrack', 'cupboard', 'instrument_guitar', 'home_office', 'dishwasher'] Task:Make coffee response:

{ Making 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:['tablelamp', 'drawing', 'hanger', 'longboard', 'floor', 'ceiling', 'bathroom_counter', 'bookshelf', 'keyboard', 'computer', 'button', 'ceilinglamp', 'tvstand', 'faucet', 'picture', 'mousepad', 'pillow', 'wall', 'basket_for_clothes', 'photoframe', 'curtain', 'shoes', 'cd', 'vacuum_cleaner', 'dresser', 'cupboard', 'clothes_dress', 'home_office', 'table', 'shoe_rack'] Task:Take off shoes response: { thoughts : Bend down to reach your feet. Shift balance to one leg. Grab the shoe of the foot of the other leg, it is best to use one hand to grip near the front, and one towards the heel. Pull the shoe down toward the ground while also pushing on the heel away from the body. Repeat with other shoe. Place shoes in a designated area., actions : ['[WALK] <bedroom>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PULL] <shoes>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTIN] <shoes> <dresser>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PULL] <shoes>', '[WALK] <dresser>', '[PUTIN] <shoes> <dresser>', '[CLOSE] <dresser>'] } Scene_Objects:['scissors', 'food_ice_cream', 'walllamp', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'shampoo', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'check', 'television', 'coin', 'curtain', 'doorjamb', 'cards', 'shoes', 'cupboard', 'door', 'sink', 'table'] Task:Watch TV response:

{ go to the living room 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:['sheets', 'filing_cabinet', 'blender', 'toilet', 'jelly', 'chair', 'drawing', 'bathroom_counter', 'floor', 'character', 'food_bacon', 'mat', 'shoe-shine_kit', 'shower', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'pasta', 'oven', 'newspaper', 'check', 'television', 'ice', 'tray', 'doorjamb', 'pencil', 'comb', 'dresser', 'bathroom_cabinet'] Task:Go to toilet response: { thoughts : Walk to the bathroom. Pull down pants. Use the toilet., actions : ['[WALK] <bathroom>', '[WALK] <clothes_pants>', '[FIND] <clothes_pants>', '[PULL] <clothes_pants>', '[FIND] <toilet>', '[SIT] <toilet>'] } Scene_Objects:['sheets', 'tablelamp', 'juice', 'walllamp', 'bathroom', 'drawing', 'hanger', 'floor', 'character', 'desk', 'tea_bag', 'mop_bucket', 'plate', 'faucet', 'couch', 'dining_room', 'broom', 'nightstand', 'bench', 'powersocket', 'box', 'photoframe', 'coffe_maker', 'food_food', 'television', 'dresser', 'cupboard', 'home_office', 'tooth_paste', 'coffee'] Task:Listen to music response:

{ I walk into the living room. I find the stereo and turn it on, and I listen to the 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', 'filing_cabinet', 'tablelamp', 'toilet', 'chair', 'freezer', 'food_egg', 'cpuscreen', 'floor', 'desk', 'tea_bag', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'stovefan', 'laptop', 'picture', 'mousepad', 'dining_room', 'wall', 'nightstand', 'photoframe', 'bed', 'mouse', 'kitchen_counter', 'maindoor', 'home_office', 'light', 'clothes_skirt'] Task:Write an email response: { thoughts : walk to home office and switch on laptop and with the useof mouse and keyboard send mail, actions : ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['pot', 'tablelamp', 'tea', 'band-aids', 'walllamp', 'nail_polish', 'knifeblock', 'bills', 'cpuscreen', 'hanger', 'shampoo', 'phone', 'floor', 'bedroom', 'desk', 'toaster', 'stereo', 'clothes_socks', 'clothes_pants', 'clothes_hat', 'bowl', 'dining_room', 'bench', 'newspaper', 'clothes_gloves', 'coffe_maker', 'curtain', 'diary', 'hairbrush', 'bathroom_cabinet'] Task:Listen to music 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:['sheets', 'tablelamp', 'chair', 'freezer', 'cat', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'toaster', 'stereo', 'faucet', 'picture', 'mousepad', 'couch', 'wall', 'nightstand', 'powersocket', 'cup', 'doorjamb', 'mouse', 'kitchen_counter', 'door', 'home_office', 'light'] Task:Listen to music response: { thoughts : I go to the bedroom and sit at my desk. I turn my radio on and listen to music., actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['fork', 'juice', 'food_ice_cream', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'faucet', 'food_noodles', 'mousepad', 'clothes_socks', 'wall', 'nightstand', 'box', 'photoframe', 'coffe_maker', 'mouse', 'kitchen_counter', 'door', 'food_steak', 'table', 'colander', 'creditcard'] Task:Work response:

{ turn computer on, open application to work with }

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:['walllamp', 'drawing', 'orchid', 'wallshelf', 'knifeblock', 'floor', 'ceiling', 'bookshelf', 'table_cloth', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'foundation', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'tray', 'curtain', 'doorjamb', 'cards', 'door', 'table', 'light', 'coffee'] Task:Watch TV response: { thoughts : I walk into the living room and sit on the sofa to watch tv, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['tea', 'microwave', 'toilet', 'walllamp', 'detergent', 'trashcan', 'floor', 'ceiling', 'envelope', 'toaster', 'plate', 'shower', 'stereo', 'dish_soap', 'wall', 'powersocket', 'basket_for_clothes', 'coffe_maker', 'food_food', 'mouthwash', 'check', 'curtain', 'kitchen_counter', 'cupboard', 'pajamas', 'conditioner', 'sink', 'spoon', 'home_office', 'dishwasher'] Task:Wash dishes with dishwasher response:

{ Walk to the kitchen. Find the dishwasher. Walk to the dishwasher. Open the dishwasher. Find plate no.1. Grab plate no.1. Put plate no.1 into the dishwasher. Find plate no.2. Grab plate no.2. Put plate no.2 into the dishwasher. Find the spoon. Grab the spoon. Put the spoon into the dishwasher. Find the dish soap. Put the dish soap into the dishwasher. Close the dishwasher. Switch on the 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:['filing_cabinet', 'blender', 'food_salt', 'toilet', 'walllamp', 'bathroom', 'food_butter', 'drawing', 'hanger', 'shampoo', 'bedroom', 'purse', 'computer', 'stovefan', 'laptop', 'ceilinglamp', 'electric_shaver', 'window', 'homework', 'clothes_socks', 'wall_clock', 'shelf', 'basket_for_clothes', 'bed', 'coffe_maker', 'check', 'wooden_spoon', 'centerpiece', 'lighter', 'kettle'] 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:['food_bread', 'microwave', 'walllamp', 'trashcan', 'bathroom_counter', 'floor', 'ceiling', 'stamp', 'keyboard', 'computer', 'alcohol', 'toaster', 'stovefan', 'shower', 'dustpan', 'pillow', 'wall', 'nightstand', 'bench', 'coffe_maker', 'check', 'food_food', 'coffee_filter', 'water', 'kitchen_counter', 'cupboard', 'table', 'dishwasher', 'tooth_paste', 'coffee'] Task:Make coffee response:

{ Go to the kitchen and make 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:['microwave', 'toilet', 'detergent', 'food_butter', 'dough', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'purse', 'faucet', 'stereo', 'picture', 'dustpan', 'bowl', 'dining_room', 'wall', 'oven', 'powersocket', 'photoframe', 'wine', 'tray', 'console', 'pencil', 'sink', 'bathroom_cabinet', 'dishwasher', 'hands_both', 'shoe_rack'] Task:Wash hands response: { thoughts : I go to the bathroom, walk to the sink, turn on the faucet and then wash my hands under the water., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>'] } Scene_Objects:['scissors', 'chair', 'walllamp', 'drawing', 'orchid', 'floor', 'phone', 'keyboard', 'brush', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'window', 'stereo', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'coffe_maker', 'curtain', 'cd', 'dishrack', 'dresser', 'cupboard', 'table', 'laser_pointer', 'clothes_shirt', 'creditcard'] Task:Relax on sofa response:

{ go to the living room,find the sofa,sat down in the sofa,take some relaxation. }

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', '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: { thoughts : 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., actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[GRAB] <phone>', '[SWITCHON] <phone>'] } Scene_Objects:['fork', 'food_salt', 'toilet', 'bathroom', 'nail_polish', 'toothbrush', 'phone', 'character', 'mat', 'shower', 'stereo', 'towel', 'dining_room', 'oven', 'basket_for_clothes', 'novel', 'television', 'oven_mitts', 'food_donut', 'tray', 'doorjamb', 'cards', 'kitchen_counter', 'dishrack', 'pajamas', 'door', 'napkin', 'light', 'table', 'soap'] Task:Pet cat response:

{ Walk into the living room, sit down by the cat, put out hand, stroke the cat from head to tail }

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', '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: { thoughts : Make coffee in the kitchen., actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[PLUGIN] <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>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>'] } Scene_Objects:['pot', 'food_ice_cream', 'microwave', 'walllamp', 'bathroom', 'cat', 'trashcan', 'knifeblock', 'hanger', 'floor', 'faucet', 'shower', 'clothes_hat', 'wall', 'nightstand', 'tape', 'cup', 'food_food', 'water', 'tray', 'diary', 'pencil', 'kitchen_counter', 'headset', 'hairbrush', 'cupboard', 'hair', 'sink', 'instrument_guitar', 'soap'] Task:Drink response:

{ Walk to kitchen, grab a glass, walk to sink, turn on tap and pour water into glass, drink from 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:['tablelamp', 'toilet', 'freezer', 'bathroom', 'orchid', 'phone', 'dvd_player', 'character', 'bedroom', 'ceilinglamp', 'balanceball', 'iron', 'window', 'couch', 'food_orange', 'wall', 'tape', 'cup', 'basket_for_clothes', 'check', 'wooden_spoon', 'console', 'mouse', 'kitchen_counter', 'hairbrush', 'food_steak', 'sink', 'home_office', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : Wash hands with soap, actions : ['[WALK] <bathroom>', '[WALK] <soap>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[WASH] <hands_both>', '[RINSE] <hands_both>'] } Scene_Objects:['pot', 'microwave', 'walllamp', 'trashcan', 'knifeblock', 'bathroom_counter', 'floor', 'mop_bucket', 'table_cloth', 'toaster', 'stovefan', 'plate', 'microphone', 'clothes_pants', 'dining_room', 'wall', 'pasta', 'cup', 'coffe_maker', 'food_food', 'mouse', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'home_office', 'light', 'dishwasher', 'colander', 'tooth_paste'] Task:Wash dishes with dishwasher response:

{ Walk to Kitchen, find dishwasher. Find vessels to be washed. Open dishwasher, put vessels in dish washer, close dish washer 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:['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:['chair', 'jelly', 'walllamp', 'dough', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'stamp', 'keyboard', 'food_cake', 'computer', 'mop_bucket', 'mat', 'tvstand', 'mousepad', 'dining_room', 'wall', 'bench', 'toy', 'food_cheese', 'novel', 'curtain', 'mouse', 'shoes', 'sink', 'table', 'creditcard'] Task:Read book response:

{ I walk to home office and search for a book, and sit to the chair with a table, and start 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:['chair', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'picture', 'mousepad', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'bathroom_cabinet', 'light'] Task:Watch TV response: { thoughts : Go to entrance hall, switch on TV, sit back in a chair and using remote watch your favorite program., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[WALK] <chair>', '[SIT] <chair>', '[TURNTO] <television>', '[WATCH] <television>', '[SWITCHOFF] <television>'] } Scene_Objects:['sheets', 'filing_cabinet', 'crayon', 'dog', 'freezer', 'knife', 'orchid', 'bathroom_counter', 'character', 'bedroom', 'faucet', 'couch', 'food_orange', 'towel', 'nightstand', 'oven', 'powersocket', 'photoframe', 'check', 'video_game_controller', 'food_donut', 'food_rice', 'food_onion', 'diary', 'dresser', 'hairbrush', 'clothes_scarf', 'napkin', 'bathroom_cabinet', 'colander'] Task:Pet cat response:

{ Walk into the living room. Walk up to the cat. Pet the cat with your hand. }

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', 'dog', 'freezer', 'drawing', 'cpuscreen', 'phone', 'tea_bag', 'food_bacon', 'stovefan', 'mat', 'ceilinglamp', 'window', 'oil', 'food_orange', 'food_cheese', 'clothes_gloves', 'toilet_paper', 'food_food', 'television', 'coffee_filter', 'check', 'curtain', 'kettle', 'mouse', 'food_steak', 'spoon', 'instrument_guitar', 'light', 'dishwasher'] Task:Walk to room response: { thoughts : Leave the living room and enter the hall, actions : ['[WALK] <home_office>', '[WALK] <home_office>'] } Scene_Objects:['pot', 'water_glass', 'dog', 'walllamp', 'knifeblock', 'bills', 'floor', 'ceiling', 'stovefan', 'brush', 'mat', 'faucet', 'homework', 'wall', 'pasta', 'oven', 'powersocket', 'food_food', 'water', 'tray', 'coffee_pot', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'napkin', 'table', 'board_game', 'clothes_shirt', 'dirt'] Task:Drink response:

{ I walk to the kitchen. open the cupboard. Find the water glass, grab it. Fill the glass with water and drink water. }

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', 'bathroom', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'floor', 'bedroom', 'bookshelf', 'keyboard', 'computer', 'couch', 'pillow', 'wall', 'wall_clock', 'powersocket', 'oven', 'photoframe', 'novel', 'check', 'television', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'light', 'table'] Task:Read response: { thoughts : Read a book in the living room, actions : ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[CLOSE] <filing_cabinet>', '[READ] <novel>'] } Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'toothbrush', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'remote_control', 'clothes_jacket', 'ceilinglamp', 'tvstand', 'mat', 'picture', 'window', 'faucet', 'couch', 'clothes_hat', 'pillow', 'food_kiwi', 'wall', 'powersocket', 'television', 'curtain', 'doorjamb', 'door', 'table', 'light'] Task:Relax on sofa response:

{ Go into the living room. Walk over to the sofa. Lie down on the sofa. Turn on 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:['sheets', 'filing_cabinet', 'juice', 'microwave', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'shower', 'faucet', 'window', 'mousepad', 'food_orange', 'wall', 'television', 'curtain', 'after_shave', 'mouse', 'dresser', 'door', 'napkin', 'table'] Task:Clean screen response: { thoughts : Use a soft rag to wipe the screen until there are no marks on it., actions : ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <computer>', '[WIPE] <computer>', '[PUTOBJBACK] <rag>'] } Scene_Objects:['sponge', 'microwave', 'walllamp', 'trashcan', 'drawing', 'floor', 'ceiling', 'button', 'toaster', 'window', 'mousepad', 'clothes_pants', 'wall', 'basket_for_clothes', 'coffe_maker', 'check', 'television', 'toothbrush_holder', 'ice', 'diary', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'pajamas', 'napkin', 'coffee_cup', 'dishwasher', 'soap', 'coffee'] Task:Make coffee response:

{ Walk to the kitchen at the coffee maker, grab coffee, pour coffee into coffee maker, put coffee into coffee maker, push coffee maker's button, wait to complete, grab coffee cup }

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', 'toilet', 'chair', 'freezer', 'food_butter', 'food_carrot', 'drawing', 'floor', 'ceiling', 'keyboard', 'mat', 'ceilinglamp', 'shower', 'oil', 'food_peanut_butter', 'food_orange', 'nightstand', 'wall', 'powersocket', 'photoframe', 'food_food', 'food_onion', 'doorjamb', 'pencil', 'dresser', 'door', 'napkin', 'light', 'shoe_rack'] Task:Put groceries in Fridge response: { thoughts : put away groceries in fridge. open the door, put on shelf, close the door., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['sheets', 'pot', 'drawing', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'mat', 'faucet', 'couch', 'dining_room', 'wall', 'newspaper', 'toilet_paper', 'television', 'oven_mitts', 'water', 'tray', 'vacuum_cleaner', 'controller', 'door', 'sink', 'napkin', 'bathroom_cabinet', 'instrument_guitar', 'light', 'soap', 'teeth'] Task:Wash teeth response:

{ Wash the teeth }

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', 'blender', 'tea', 'toilet', 'chair', 'freezer', 'drawing', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'dvd_player', 'stovefan', 'ceilinglamp', 'mat', 'shower', 'food_jam', 'wall', 'nightstand', 'powersocket', 'cutting_board', 'cup', 'food_vegetable', 'photoframe', 'basket_for_clothes', 'doorjamb', 'mouse', 'door', 'table', 'light'] Task:Chop vegetables response: { thoughts : Cut up veggies with knife, actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <knife>', '[GRAB] <knife>', '[FIND] <cutting_board>', '[GRAB] <cutting_board>', '[CLOSE] <kitchen_cabinet>', '[WALK] <table>', '[PUTBACK] <knife> <table>', '[PUTBACK] <cutting_board> <table>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[CLOSE] <freezer>', '[WALK] <table>', '[PUTBACK] <food_vegetable> <cutting_board>', '[GRAB] <knife>', '[CUT] <food_vegetable>', '[PUTOBJBACK] <knife>'] } Scene_Objects:['glue', 'filing_cabinet', 'tablelamp', 'microwave', 'freezer', 'ground_coffee', 'walllamp', 'bathroom', 'trashcan', 'floor', 'ceiling', 'phone', 'computer', 'toaster', 'stovefan', 'homework', 'wall', 'novel', 'coffe_maker', 'television', 'coffee_filter', 'water', 'tray', 'after_shave', 'diary', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'food_steak', 'dishwasher'] Task:Make coffee response:

{ 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. }

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', 'microwave', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'toaster', 'mat', 'plate', 'faucet', 'window', 'dish_soap', 'food_noodles', 'closetdrawer', 'couch', 'towel', 'dining_room', 'wall', 'wine', 'rag', 'shaving_cream', 'kitchen_counter', 'chessboard', 'dresser', 'cupboard', 'conditioner', 'sink', 'table', 'dishwasher', 'soap'] Task:Wash dishes response: { thoughts : Run warm water in the sink. Pour dish washing liquid on the dishes. Pick up dishes and wash them individually with a sponge. Rinse suds off under running water. Dry dishes with towel., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[WASH] <plate>', '[RINSE] <plate>', '[RINSE] <sponge>', '[SWITCHOFF] <faucet>', '[PUTOBJBACK] <sponge>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <plate>', '[PUTOBJBACK] <towel>', '[WALK] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[PUTIN] <plate> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>'] } Scene_Objects:['toilet', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'television', 'tray', 'curtain', 'doorjamb', 'dresser', 'hairbrush', 'clothes_dress', 'door', 'sink', 'spoon', 'table', 'light'] Task:Change TV channel response:

{ I walk into the living room. I sit on the couch and grab the remote. Then I turn on the TV and change the 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:['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: { thoughts : walk to the bathroom, grab the basket for clothes, find soap, put in washing machine, turn on, actions : ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[WALK] <washing_machine>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['pot', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'bedroom', 'bookshelf', 'remote_control', 'thread', 'brush', 'ceilinglamp', 'tvstand', 'mat', 'toaster', 'clothes_hat', 'dining_room', 'wall', 'powersocket', 'cup', 'photoframe', 'television', 'doorjamb', 'pencil', 'dresser', 'door', 'home_office', 'table', 'light'] Task:Change TV channel response:

{ Change the channel on the 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:['dry_pasta', 'food_bread', 'microwave', 'freezer', 'ground_coffee', 'dough', 'orchid', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'tea_bag', 'toaster', 'faucet', 'shower', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'oven', 'cutting_board', 'photoframe', 'coffe_maker', 'coffee_filter', 'water', 'curtain', 'kitchen_counter', 'cupboard', 'sink'] Task:Make coffee response: { thoughts : I walk to the kitchen and find the coffee machine. I open the coffee machine and pour a filter in it. I open the cupboard and grab ground coffee. I put ground coffee in the filter and water in the coffee machine. I close the coffee machine. I switch on the coffee machine and wait, 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] <cupboard>', '[OPEN] <cupboard>', '[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', 'filing_cabinet', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mat', 'shoe-shine_kit', 'mousepad', 'pillow', 'wall', 'powersocket', 'cup', 'bed', 'wooden_spoon', 'coffee_pot', 'mouse', 'kitchen_counter', 'door', 'home_office', 'table'] Task:Write an email response:

{ I walk to the Home Office then find the computer and sit in the chair. I switch on the computer and start typing the email. I switch the computer 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:['dry_pasta', 'filing_cabinet', 'freezer', 'walllamp', 'cpuscreen', 'wallshelf', 'ceiling', 'computer', 'shower', 'window', 'mousepad', 'couch', 'dining_room', 'wall_clock', 'oven', 'powersocket', 'bench', 'cup', 'bed', 'photoframe', 'check', 'coffe_maker', 'razor', 'mouse', 'cupboard', 'laundry_detergent', 'door', 'home_office', 'light', '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:['sponge', 'pot', 'blender', 'food_ice_cream', 'microwave', 'chair', 'walllamp', 'bathroom', 'trashcan', 'milk', 'floor', 'bedroom', 'computer', 'toaster', 'plate', 'shoe-shine_kit', 'oil', 'wall', 'newspaper', 'coffe_maker', 'tray', 'centerpiece', 'console', 'pencil', 'kitchen_counter', 'cupboard', 'spoon', 'dishwasher', 'laser_pointer', 'clothes_shirt'] Task:Wash dishes with dishwasher response:

{ I walk to the kitchen. I take plate. I open the dishwasher. I put plate in the dishwasher. I switch on the 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:['filing_cabinet', 'tablelamp', 'microwave', 'chair', 'freezer', 'detergent', 'floor', 'phone', 'ceiling', 'bedroom', 'keyboard', 'stovefan', 'shower', 'faucet', 'window', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'bench', 'photoframe', 'coffe_maker', 'check', 'television', 'food_food', 'ice', 'rag', 'towel_rack', 'kitchen_counter', 'cupboard'] Task:Turn on light response: { thoughts : I go home and it's dark so I can not see anything, actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>'] } Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'toilet', 'food_carrot', 'toothbrush', 'drawing', 'cpuscreen', 'floor', 'bedroom', 'bookshelf', 'thread', 'tvstand', 'shower', 'clothes_pants', 'towel', 'wall', 'pasta', 'bench', 'photoframe', 'light_bulb', 'food_food', 'television', 'curtain', 'doorjamb', 'kettle', 'door', 'sink', 'hairdryer', 'light'] Task:Go to toilet response:

{ Walk to the bathroom. Pull down pants. Use 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:['milk', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'bedroom', 'desk', 'brush', 'mat', 'ceilinglamp', 'closetdrawer', 'couch', 'dustpan', 'pillow', 'wall', 'powersocket', 'cup', 'photoframe', 'coffee_filter', 'food_rice', 'doorjamb', 'towel_rack', 'dresser', 'clothes_dress', 'door', 'light', 'table'] Task:Change clothes response: { thoughts : Switch your clothes., actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[PUTON] <clothes_dress>', '[CLOSE] <dresser>'] } Scene_Objects:['blender', 'beer', 'freezer', 'trashcan', 'orchid', 'floor', 'ceiling', 'bedroom', 'computer', 'toaster', 'window', 'couch', 'candle', 'dining_room', 'broom', 'oven', 'toy', 'check', 'video_game_controller', 'tray', 'kettle', 'coffee_pot', 'mouse', 'cd', 'cupboard', 'controller', 'bathroom_cabinet', 'light', 'dishwasher', 'laser_pointer'] Task:Browse internet response:

{ I pick up my phone. I touch it to navigate to the web browser. I can swipe and tap the screen to visit different websites. Then I read or watch the content within those websites. }

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', 'microwave', 'jelly', 'freezer', 'walllamp', 'drawing', 'character', 'tea_bag', 'stovefan', 'mat', 'tvstand', 'stereo', 'shoe-shine_kit', 'window', 'ceilinglamp', 'dustpan', 'food_jam', 'pillow', 'wall', 'wall_clock', 'newspaper', 'coffe_maker', 'food_donut', 'doorjamb', 'coffee_pot', 'cards', 'door', 'bathroom_cabinet', 'colander', 'scrabble'] Task:Listen to music response: { thoughts : I reach out arm. I put hand on radio. I turn on radio. I pick a station., actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[TOUCH] <stereo>', '[TURNTO] <stereo>'] } Scene_Objects:['dry_pasta', 'sheets', 'toilet', 'chair', 'freezer', 'ground_coffee', 'bathroom', 'cat', 'milk', 'food_egg', 'phone', 'clothes_jacket', 'mat', 'plate', 'tvstand', 'stereo', 'faucet', 'shower', 'couch', 'food_jam', 'pillow', 'cup', 'novel', 'coffe_maker', 'coffee_filter', 'ice', 'curtain', 'kitchen_counter', 'spoon', 'clothes_shirt'] Task:Give milk to cat response:

{ Grab milk and pour it into the plate so that the cat can 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:['microwave', 'chair', 'freezer', 'walllamp', 'trashcan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'mat', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'toy', 'television', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'table'] Task:Pay bills response: { thoughts : Check my bills, on the computer, open the appropriate sites, pay my due bills, actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[SWITCHOFF] <computer>'] } Scene_Objects:['mop', 'walllamp', 'drawing', 'orchid', 'knife', 'floor', 'ceiling', 'folder', 'remote_control', 'food_cake', 'button', 'ceilinglamp', 'tvstand', 'mat', 'clothes_socks', 'pillow', 'dining_room', 'wall', 'powersocket', 'bed', 'toilet_paper', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'dishrack', 'clothes_dress', 'door', 'table', 'dishwasher'] Task:Change TV channel response:

{ Walk to the living room. Find the television. Switch on the television. Find the remote control. Grab the remote control. Point at television. Find the button. Push 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:['glue', 'filing_cabinet', 'blow_dryer', 'walllamp', 'knife', 'orchid', 'cpuscreen', 'floor', 'computer', 'button', 'ceilinglamp', 'oil', 'mousepad', 'cup', 'bed', 'keys', 'novel', 'check', 'coffe_maker', 'toothbrush_holder', 'coffee_filter', 'food_food', 'curtain', 'pencil', 'shoes', 'controller', 'hairdryer', 'bathroom_cabinet', 'table', 'board_game'] Task:Get ready to leave response: { thoughts : Get your jacket and shoes on, locate the keys off the side table, walk out the front door and secure building with keys when you leave, actions : ['[WALK] <home_office>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>', '[FIND] <keys>', '[GRAB] <keys>'] } Scene_Objects:['pot', 'measuring_cup', 'toilet', 'chair', 'band-aids', 'freezer', 'walllamp', 'food_carrot', 'toothbrush', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'button', 'mat', 'tvstand', 'faucet', 'mousepad', 'food_kiwi', 'wall', 'light_bulb', 'coffe_maker', 'toothbrush_holder', 'rag', 'pencil', 'sink', 'bathroom_cabinet', 'soap', 'tooth_paste', 'teeth'] Task:Brush teeth response:

{ getting ready for bed }

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', 'blender', 'chair', 'bathroom', 'hanger', 'floor', 'tea_bag', 'food_cake', 'food_bacon', 'piano_bench', 'mat', 'plate', 'dish_soap', 'mousepad', 'closetdrawer', 'couch', 'clothes_socks', 'wall', 'powersocket', 'coffe_maker', 'curtain', 'console', 'kitchen_counter', 'cupboard', 'door', 'sink', 'napkin', 'dishwasher', 'colander'] 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:['spectacles', 'food_bread', 'crayon', 'measuring_cup', 'chair', 'walllamp', 'trashcan', 'bedroom', 'bookshelf', 'purse', 'table_cloth', 'faucet', 'clothes_socks', 'pillow', 'wall', 'oven', 'newspaper', 'photoframe', 'coffe_maker', 'food_food', 'check', 'coffee_filter', 'shaving_cream', 'pencil', 'headset', 'dishrack', 'comb', 'dresser', 'spoon', 'instrument_guitar'] Task:Turn on light response:

{ walk to living room, find lamp, switch 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', 'dough', 'drawing', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'tvstand', 'stereo', 'mousepad', 'pillow', 'food_kiwi', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'door', 'sink', 'bathtub', 'light'] Task:Listen to music response: { thoughts : I go to the bedroom and sit at my desk. I turn my radio on and listen to music., actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['filing_cabinet', 'food_salt', 'freezer', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'homework', 'window', 'wall', 'powersocket', 'oven', 'toy', 'bed', 'toilet_paper', 'television', 'toothbrush_holder', 'food_donut', 'tray', 'doorjamb', 'door', 'sink', 'spoon', 'table'] Task:Change TV channel response:

{ Lift the remote and change the 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:['food_salt', 'beer', 'microwave', 'chair', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'mop_bucket', 'toaster', 'brush', 'plate', 'faucet', 'stereo', 'ceilinglamp', 'tvstand', 'dish_soap', 'wall', 'food_food', 'video_game_controller', 'toothbrush_holder', 'doorjamb', 'mouse', 'kitchen_counter', 'headset', 'cupboard', 'sink', 'light', 'table'] Task:Wash dishes by hand response: { thoughts : i go to the kitchen, i find the faucet. I turn the faucet on, i grab the plate to wash , i then get the soap. I wash the dishes by hand, actions : ['[WALK] <dining_room>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[WASH] <plate>'] } Scene_Objects:['microwave', 'freezer', 'walllamp', 'nail_polish', 'food_carrot', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'toaster', 'ceilinglamp', 'plate', 'mousepad', 'wall', 'powersocket', 'oven', 'food_food', 'coffe_maker', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'napkin', 'light', 'dishwasher'] Task:Cook some food response:

{ Walk Into Kitchen. Open Refrigerator. Grab Food. Walk to Microwave. Insert food into microwave. Cook until warm. }

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', 'walllamp', 'cat', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'plate', 'couch', 'pillow', 'wall', 'newspaper', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'bathtub', 'light', 'table'] Task:Pet cat response: { thoughts : My cat looks like it wants attention, so I will go pet it on the couch., actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <cat>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'knifeblock', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'computer', 'bookmark', 'stovefan', 'ceilinglamp', 'mat', 'mousepad', 'oil', 'food_peanut_butter', 'broom', 'wall', 'novel', 'diary', 'mouse', 'cupboard', 'clothes_dress', 'door', 'table', 'light', 'dirt'] Task:Browse internet response:

{ Go to office. Turn on computer. Pull out chair. Sit in chair. Use keyboard and mouse. }

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', 'juice', 'toilet', 'walllamp', 'toothbrush', 'drawing', 'cpuscreen', 'clothes_underwear', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'stamp', 'faucet', 'balanceball', 'clothes_pants', 'wall', 'powersocket', 'photoframe', 'novel', 'toothbrush_holder', 'television', 'food_donut', 'tray', 'towel_rack', 'cupboard', 'controller', 'sink', 'bathroom_cabinet', '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:['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:

{ 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. }

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', 'microwave', 'freezer', 'orchid', 'floor', 'desk', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'window', 'mousepad', 'pillow', 'nightstand', 'wall_clock', 'oven', 'wall', 'coffe_maker', 'mouthwash', 'television', 'tray', 'towel_rack', 'pencil', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'bathroom_cabinet', 'light'] Task:Pick up phone response: { thoughts : walk to phone, grab phone, pick up phone, put to ear, actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>'] } Scene_Objects:['juice', 'food_salt', 'cd_player', 'toilet', 'freezer', 'walllamp', 'nail_polish', 'drawing', 'orchid', 'knifeblock', 'floor', 'phone', 'keyboard', 'computer', 'button', 'toaster', 'ceilinglamp', 'window', 'couch', 'pillow', 'bowl', 'wall', 'oven', 'photoframe', 'check', 'curtain', 'kettle', 'pajamas', 'table', 'light'] Task:Listen to music response:

{ Walk to living room, walk to cd player, turn on cd player, press play button, walk to sofa, sit in sofa 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:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'wooden_spoon', 'doorjamb', 'mouse', 'dresser', 'door'] Task:Browse internet response: { thoughts : I go to my home office. I sit on the chair right in front of my computer. I turn on the computer. Use the mouse to open the web browser. Use the keyboard to type the URL that I want to visit., actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[TOUCH] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['toilet', 'bathroom', 'trashcan', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'alcohol', 'mat', 'electric_shaver', 'oil', 'wall', 'powersocket', 'box', 'food_cheese', 'photoframe', 'bed', 'food_food', 'coffe_maker', 'doorjamb', 'lighter', 'dishrack', 'door', 'bathroom_cabinet', 'light', 'dishwasher', 'coffee'] Task:Turn on light response:

{ push any ligth button to turn it on, for example 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:['microwave', 'toilet', 'freezer', 'walllamp', 'food_carrot', 'orchid', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'character', 'shoe-shine_kit', 'faucet', 'couch', 'form', 'wall', 'bench', 'toy', 'cup', 'coffe_maker', 'television', 'doorjamb', 'towel_rack', 'mouse', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'home_office', 'soap'] Task:Wash hands response: { thoughts : walk to bathroom, find sink, turn on faucet, put soap in hands, wash and rinse hands,, actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <soap>', '[WASH] <soap>', '[RINSE] <soap>'] } Scene_Objects:['juice', 'microwave', 'toilet', 'freezer', 'bathroom', 'orchid', 'knifeblock', 'phone', 'character', 'stovefan', 'mat', 'shower', 'dustpan', 'food_orange', 'pillow', 'broom', 'box', 'newspaper', 'check', 'television', 'coffee_pot', 'controller', 'door', 'home_office', 'table', 'bathroom_cabinet', 'dishwasher', 'colander', 'teeth', 'shoe_rack'] Task:Pick up phone response:

{ Enter the Home office, then walk to the phone, pickup 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:['tablelamp', 'nail_polish', 'bathroom', 'cat', 'orchid', 'cpuscreen', 'longboard', 'bedroom', 'keyboard', 'clothes_jacket', 'bookmark', 'toaster', 'balanceball', 'stereo', 'mousepad', 'clothes_pants', 'pillow', 'nightstand', 'wall', 'photoframe', 'food_food', 'mouthwash', 'tray', 'diary', 'comb', 'pajamas', 'maindoor', 'bag', 'spoon', 'light'] Task:Pet cat response: { thoughts : Go to the living room where the cat sleeps. Find cat. Proceed to petting cat., actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['freezer', 'band-aids', 'dough', 'cpuscreen', 'food_egg', 'floor', 'ceiling', 'dvd_player', 'desk', 'bedroom', 'keyboard', 'computer', 'clothes_jacket', 'ceilinglamp', 'mat', 'mousepad', 'wall', 'powersocket', 'cup', 'bed', 'photoframe', 'newspaper', 'water', 'food_donut', 'doorjamb', 'mouse', 'door', 'light', 'table', 'shoe_rack'] Task:Drink response:

{ Feeling tired after hard work I opened the fridge and grabbed cool water and drank 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:['toilet', 'freezer', 'walllamp', 'cat', 'ceilingfan', 'drawing', 'cpuscreen', 'clothes_underwear', 'longboard', 'floor', 'ceiling', 'keyboard', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'oil', 'couch', 'pillow', 'wall', 'photoframe', 'food_food', 'television', 'ice', 'curtain', 'after_shave', 'door', 'table', 'dishwasher', 'vase'] Task:Watch TV response: { thoughts : Sit on couch and watch the tv, actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['tablelamp', 'blender', 'mop', 'bathroom', 'cat', 'trashcan', 'knifeblock', 'stamp', 'button', 'piano_bench', 'faucet', 'mousepad', 'bowl', 'nightstand', 'wall_clock', 'oven', 'wall', 'bench', 'photoframe', 'novel', 'food_food', 'coffe_maker', 'curtain', 'pencil', 'shoes', 'hairbrush', 'hair', 'instrument_guitar', 'dishwasher', 'tooth_paste'] Task:Read book response:

{ pick up the book open the book and read }

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', 'band-aids', 'walllamp', 'detergent', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'homework', 'faucet', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'keys', 'television', 'doorjamb', 'kitchen_counter', 'dresser', 'light', 'soap'] Task:Change TV channels response: { thoughts : Take remote. Change to desired channel by you., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <remote_control>', '[TOUCH] <remote_control>', '[TOUCH] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[WATCH] <television>', '[WATCH] <television>'] } Scene_Objects:['fork', 'tablelamp', 'chair', 'freezer', 'drawing', 'knifeblock', 'cpuscreen', 'needle', 'floor', 'ceiling', 'desk', 'stamp', 'keyboard', 'computer', 'brush', 'mousepad', 'wall', 'nightstand', 'bed', 'photoframe', 'check', 'food_food', 'doorjamb', 'mouse', 'kitchen_counter', 'headset', 'door', 'table', 'light', 'shoe_rack'] Task:Listen to music response:

{ I'll walk to my bedroom, where I have my computer. I'll walk to my computer and sit down in front of it. I'll put on my headphones and unlock my computer. I'll then navigate to music stored locally or streamed through the web. }

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', 'filing_cabinet', 'jelly', 'drawing', 'orchid', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'computer', 'bookmark', 'faucet', 'clothes_socks', 'couch', 'pillow', 'broom', 'wall', 'wall_clock', 'tape', 'photoframe', 'novel', 'check', 'food_onion', 'doorjamb', 'door', 'bathtub', 'table', 'light'] Task:Relax on sofa response: { thoughts : Go to the living room and relax on the sofa with a book, actions : ['[RUN] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[DROP] <bookmark>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[READ] <novel>', '[READ] <novel>', '[READ] <novel>'] } Scene_Objects:['cd_player', 'walllamp', 'drawing', 'knife', 'knifeblock', 'ceiling', 'character', 'keyboard', 'ceilinglamp', 'tvstand', 'stereo', 'shower', 'faucet', 'window', 'food_noodles', 'mousepad', 'couch', 'dustpan', 'dining_room', 'food_kiwi', 'wall_clock', 'bench', 'powersocket', 'oven', 'toy', 'photoframe', 'ice', 'dishrack', 'clothes_skirt', 'coffee'] Task:Listen to music response:

{ I walk in the living room, then I go the the stereo and the cd player and turn them 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:['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:['filing_cabinet', 'freezer', 'band-aids', 'trashcan', 'dough', 'food_egg', 'cpuscreen', 'floor', 'ceiling', 'folder', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'pillow', 'wall', 'powersocket', 'newspaper', 'food_food', 'check', 'oven_mitts', 'food_donut', 'food_onion', 'doorjamb', 'kettle', 'mouse', 'pajamas', 'door', 'light'] Task:Put groceries in Fridge response:

{ go to the kitchen and put the groceries in 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:['dry_pasta', 'pot', 'microwave', 'walllamp', 'toothbrush', 'drawing', 'knifeblock', 'wallshelf', 'keyboard', 'food_cake', 'ceilinglamp', 'tvstand', 'shower', 'stereo', 'oil', 'tooth_paste', 'couch', 'closetdrawer', 'dining_room', 'toy', 'basket_for_clothes', 'light_bulb', 'check', 'centerpiece', 'kettle', 'mouse', 'kitchen_counter', 'shoes', 'light', 'board_game'] Task:Brush teeth response: { thoughts : EARLY MORNING AND BEFORE GOING TO BED, actions : ['[WALK] <bathroom>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>'] } Scene_Objects:['pot', 'filing_cabinet', 'scissors', 'mop', 'microwave', 'toilet', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'desk', 'bookshelf', 'tvstand', 'shower', 'stereo', 'mousepad', 'wall', 'powersocket', 'photoframe', 'bed', 'food_food', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'chessboard', 'laundry_detergent', 'door', 'board_game'] Task:Go to toilet response:

{ walk to bathroom , run to 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:['pot', 'food_ice_cream', 'microwave', 'freezer', 'walllamp', 'blow_dryer', 'detergent', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'table_cloth', 'stovefan', 'toaster', 'faucet', 'mousepad', 'wall', 'wall_clock', 'oven', 'cup', 'coffe_maker', 'food_food', 'water', 'tray', 'cards', 'kitchen_counter', 'cupboard', 'sink', 'light', 'dishwasher'] Task:Drink response: { thoughts : Walk to kitchen, grab a cup, fill with water and then drink it., actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <cup>', '[GRAB] <cup>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[FIND] <sink>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[DRINK] <cup>'] } Scene_Objects:['filing_cabinet', 'beer', 'freezer', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'shampoo', 'bookshelf', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'foundation', 'window', 'wall', 'powersocket', 'cup', 'photoframe', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'door', 'table', 'light'] Task:Change TV channel response:

{ Walk into the Living room. Find the television remote. Use it to turn on the television. Point the remote at the television. Press the channel 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:['blender', 'microwave', 'chair', 'freezer', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'ceilinglamp', 'tvstand', 'stereo', 'picture', 'mat', 'closetdrawer', 'couch', 'dining_room', 'wall_clock', 'bench', 'food_food', 'coffe_maker', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'cupboard', 'home_office', 'instrument_guitar'] Task:Turn on light response: { thoughts : I walk into the living room and then I walk to the light switch in there and turn the lights on, actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[SWITCHON] <floor_lamp>'] } Scene_Objects:['sheets', 'pot', 'chair', 'walllamp', 'food_butter', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'shower', 'picture', 'mousepad', 'pillow', 'wall', 'oven', 'powersocket', 'bed', 'photoframe', 'food_donut', 'tray', 'mouse', 'pencil', 'bag', 'soap'] Task:Read book response:

{ go to living room,find the text book on the self ,sat on the chair ,open and read the 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:['microwave', 'chair', 'freezer', 'band-aids', 'walllamp', 'cat', 'drawing', 'floor', 'alcohol', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'deck_of_cards', 'window', 'shower', 'couch', 'pillow', 'wall', 'wall_clock', 'oven', 'photoframe', 'keys', 'television', 'curtain', 'doorjamb', 'mouse', 'home_office', 'table', 'bathroom_cabinet'] 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:['tablelamp', 'blender', 'trashcan', 'drawing', 'floor', 'phone', 'ceiling', 'desk', 'purse', 'mat', 'tvstand', 'ceilinglamp', 'window', 'food_peanut_butter', 'food_jam', 'pillow', 'wall', 'bench', 'check', 'toothbrush_holder', 'colander', 'tray', 'rag', 'lighter', 'kitchen_counter', 'comb', 'door', 'table', 'dishwasher', 'soap'] Task:Pick up phone response:

{ Pick up 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:['beer', 'crayon', 'ceilingfan', 'drawing', 'needle', 'floor', 'ceiling', 'shampoo', 'keyboard', 'remote_control', 'thread', 'food_bacon', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'wall', 'photoframe', 'bed', 'television', 'coffee_filter', 'curtain', 'mouse', 'table', 'light', 'laser_pointer'] Task:Watch TV response: { thoughts : I go into the living room. I find the remote. I turn on the tv. I sit on the couch and watch tv., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['sheets', 'tablelamp', 'freezer', 'knifeblock', 'knife', 'bathroom_counter', 'shampoo', 'ceiling', 'keyboard', 'stovefan', 'mat', 'stereo', 'clothes_socks', 'oil', 'nightstand', 'powersocket', 'toy', 'novel', 'food_food', 'coffe_maker', 'rag', 'kettle', 'shoes', 'cupboard', 'hair', 'controller', 'door', 'instrument_guitar', 'table', 'light'] Task:Listen to music response:

{ walk into living room, walk to stereo, turn on stereo, 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:['walllamp', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'clothes_pants', 'form', 'pillow', 'towel', 'wall', 'powersocket', 'bench', 'newspaper', 'television', 'curtain', 'doorjamb', 'mouse', 'hair', 'door', 'bathroom_cabinet', 'table', 'dishwasher'] Task:Watch TV response: { thoughts : SIT ON THE COUCH, TURN TV ON WITH REMOTE, FIND A SHOW, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['spectacles', 'pot', 'filing_cabinet', 'food_pizza', 'walllamp', 'cat', 'toothbrush', 'orchid', 'hanger', 'bathroom_counter', 'ceiling', 'bedroom', 'food_bacon', 'table_cloth', 'plate', 'food_jam', 'bench', 'oven', 'tape', 'photoframe', 'toothbrush_holder', 'oven_mitts', 'wooden_spoon', 'diary', 'mouse', 'sink', 'home_office', 'light', 'tooth_paste', 'clothes_shirt'] Task:Brush teeth response:

{ today morning i went to bathroom and took my toothbrush and paste from tooth brush holder and brushed and cleaned my teeth well }

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', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'dresser', 'door', 'light'] Task:Work response: { thoughts : Walk to over to desk, sit down on chair and face the computer, turn the computer on, use arms to place hands on the keyboard, type work into the computer and use eyes to review., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['fork', 'pot', 'tablelamp', 'freezer', 'bathroom', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'toaster', 'ceilinglamp', 'mousepad', 'food_jam', 'pillow', 'wall', 'powersocket', 'light_bulb', 'drinking_glass', 'food_onion', 'doorjamb', 'mouse', 'cd', 'door', 'light', 'clothes_skirt', 'coffee'] Task:Drink response:

{ Robot Drinks the water }

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', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'mouse', 'dresser', 'conditioner', 'door', 'table', 'shoe_rack'] Task:Relax on sofa response: { thoughts : For relaxing walk to living room. Find the sofa to relax. Arrange the sofa to relax. Sit on the sofa to relaxing., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[FIND] <conditioner>', '[FIND] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[LIE] <couch>'] } Scene_Objects:['pot', 'chair', 'band-aids', 'bathroom', 'trashcan', 'phone', 'bedroom', 'bookshelf', 'computer', 'stovefan', 'picture', 'window', 'couch', 'bowl', 'broom', 'wall', 'oven', 'bench', 'cup', 'food_food', 'oven_mitts', 'colander', 'curtain', 'pencil', 'kitchen_counter', 'clothes_dress', 'sink', 'dishwasher', 'soap', 'instrument_violin'] Task:Pet cat response:

{ Find Cat in living room. Walk to cat. Pet 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', '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:['glue', 'tea', 'microwave', 'walllamp', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'phone', 'toaster', 'shower', 'faucet', 'food_noodles', 'mousepad', 'microphone', 'pillow', 'wall', 'bed', 'light_bulb', 'coffe_maker', 'toothbrush_holder', 'coffee_filter', 'oven_mitts', 'razor', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher', 'coffee'] Task:Make coffee response:

{ Enter kitchen, find coffee maker, find coffee filter, pick up coffee filter, put it in coffee maker, find coffee, pour coffee into filter, 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:['microwave', 'toilet', 'chair', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'tvstand', 'window', 'mousepad', 'dustpan', 'pillow', 'wall', 'wall_clock', 'powersocket', 'television', 'tray', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'table'] Task:Browse internet response: { thoughts : Browsing the internet for information., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <mouse>', '[TOUCH] <mouse>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['tablelamp', 'cd_player', 'walllamp', 'trashcan', 'food_carrot', 'drawing', 'needle', 'bathroom_counter', 'dvd_player', 'bedroom', 'bookshelf', 'alcohol', 'piano_bench', 'bookmark', 'laptop', 'stereo', 'couch', 'pillow', 'broom', 'bench', 'basket_for_clothes', 'mouse', 'shoes', 'headset', 'food_steak', 'sink', 'hairdryer', 'instrument_guitar', 'door', 'bag'] Task:Listen to music response:

{ Find the playback device you want to listen to. turn on. press play. enjoyu 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:['dry_pasta', 'tablelamp', 'food_salt', 'chair', 'walllamp', 'detergent', 'drawing', 'clothes_underwear', 'floor', 'bedroom', 'toaster', 'ceilinglamp', 'tvstand', 'shower', 'food_noodles', 'garbage_can', 'mousepad', 'microphone', 'wall', 'nightstand', 'food_vegetable', 'bed', 'food_food', 'coffee_filter', 'mouse', 'sink', 'home_office', 'table', 'dishwasher', 'pantry'] Task:Organize pantry response: { thoughts : Remove all perishable foods from the pantry, check dates and throw away any old food. Decide on an efficient ad neat arrangement for the food and replace it in the pantry accordingly., actions : ['[WALK] <dining_room>', '[WALK] <pantry>', '[FIND] <food_food>', '[GRAB] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[FIND] <garbage_can>', '[PUTBACK] <food_food> <garbage_can>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[TURNTO] <food_vegetable>', '[LOOKAT] <food_vegetable>', '[PUTBACK] <food_vegetable> <garbage_can>', '[FIND] <dry_pasta>', '[GRAB] <dry_pasta>', '[TURNTO] <dry_pasta>', '[LOOKAT] <dry_pasta>', '[PUTOBJBACK] <dry_pasta>', '[FIND] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[PUSH] <food_food>', '[FIND] <food_noodles>', '[GRAB] <food_noodles>', '[TURNTO] <food_noodles>', '[LOOKAT] <food_noodles>', '[PUTOBJBACK] <food_noodles>'] } Scene_Objects:['tablelamp', 'food_ice_cream', 'walllamp', 'trashcan', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'tea_bag', 'bookshelf', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'mat', 'deck_of_cards', 'homework', 'wall', 'powersocket', 'check', 'television', 'doorjamb', 'mouse', 'cupboard', 'controller', 'door', 'bag', 'table', 'teeth'] Task:Change TV channel response:

{ Go to the living room, Switch on the television. Find the remote and press the change channel button, change the 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:['food_pizza', 'food_salt', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'computer', 'mat', 'faucet', 'closetdrawer', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'toy', 'novel', 'toothbrush_holder', 'wine', 'doorjamb', 'shaving_cream', 'kitchen_counter', 'door', 'sink', 'clothes_scarf', 'light'] Task:Turn on light response: { thoughts : Walk into living room. Find wall. Find light button. Switch on light button., actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['sheets', 'pot', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'plate', 'stereo', 'mousepad', 'wall', 'bench', 'television', 'wine', 'rag', 'lighter', 'shaving_cream', 'mouse', 'hairbrush', 'door', 'table'] Task:Write an email response:

{ walk to living room, look at computer, find chair, sit in chair, grab keyboard, grab mouse, type using keyboard and mouse }

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', 'chair', 'jelly', 'walllamp', 'detergent', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'phone', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'window', 'homework', 'closetdrawer', 'couch', 'pillow', 'wall', 'newspaper', 'coffe_maker', 'television', 'tray', 'curtain', 'towel_rack', 'cupboard', 'home_office', 'table'] Task:Read newspaper response: { thoughts : Read the newspaper on the couch, actions : ['[WALK] <home_office>', '[WALK] <newspaper>', '[FIND] <newspaper>', '[GRAB] <newspaper>', '[FIND] <couch>', '[SIT] <couch>', '[READ] <newspaper>'] } Scene_Objects:['microwave', 'walllamp', 'orchid', 'drawing', 'floor', 'ceiling', 'phone', 'remote_control', 'mop_bucket', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'cup', 'newspaper', 'television', 'toothbrush_holder', 'curtain', 'doorjamb', 'shoes', 'dresser', 'door', 'home_office', 'table'] Task:Watch TV response:

{ I get home from work and decide to watch tv. I go to the living room and turn on the tv. I sit on the couch and use the remote to switch the channels to find what I want to 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:['tablelamp', 'microwave', 'walllamp', 'bathroom', 'hanger', 'bathroom_counter', 'man', 'bookshelf', 'keyboard', 'piano_bench', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'window', 'closetdrawer', 'dining_room', 'photoframe', 'tray', 'curtain', 'food_onion', 'mouse', 'dresser', 'cupboard', 'door', 'sink', 'home_office', 'light', 'clothes_skirt', 'bathroom_cabinet'] Task:Greet guests response: { thoughts : When someone knocks I n the door walk through the hallway and greet them., actions : ['[RUN] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <man>', '[GREET] <man>'] } Scene_Objects:['pot', 'walllamp', 'trashcan', 'milk', 'knifeblock', 'orchid', 'kitchen_cabinet', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'toaster', 'stovefan', 'faucet', 'mousepad', 'couch', 'wall', 'pasta', 'oven', 'box', 'food_food', 'water', 'tray', 'pencil', 'kitchen_counter', 'sauce_pan', 'cupboard', 'instrument_guitar', 'bathroom_cabinet'] Task:Cook some food response:

{ Cook some pasta on the stove }

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', 'tea', 'microwave', 'toilet', 'freezer', 'bathroom', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'folder', 'bookshelf', 'computer', 'toaster', 'mat', 'shower', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'bench', 'cup', 'food_food', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'napkin'] Task:Put groceries in Fridge response: { thoughts : Find groceries. Grab groceries. Walk to refrigerator. Open refrigerator door. Place groceries into refrigerator. Close refrigerator door., actions : ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['pot', 'filing_cabinet', 'tea', 'toilet', 'dog', 'trashcan', 'orchid', 'drawing', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'alcohol', 'toaster', 'mat', 'shower', 'picture', 'stereo', 'clothes_socks', 'wall', 'nightstand', 'photoframe', 'check', 'razor', 'curtain', 'doorjamb', 'pencil', 'door', 'napkin', 'laser_pointer'] Task:Go to toilet response:

{ i go to the bathroom. I find 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', 'microwave', 'toilet', 'cat', 'drawing', 'floor', 'dvd_player', 'bookshelf', 'food_cake', 'keyboard', 'computer', 'bookmark', 'mat', 'shower', 'faucet', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'television', 'curtain', 'towel_rack', 'mouse', 'door', 'sink', 'bathtub', 'light'] Task:Breakfast response: { thoughts : I have breakfast in bed, watching tv., actions : ['[WALK] <dining_room>', '[WALK] <food_food>', '[GRAB] <food_food>', '[WALK] <bedroom>', '[WALK] <television>', '[SWITCHON] <television>', '[WALK] <bed>', '[LIE] <bed>', '[TURNTO] <television>', '[WATCH] <television>', '[EAT] <food_food>'] } Scene_Objects:['water_glass', 'mop', 'freezer', 'bathroom', 'trashcan', 'knifeblock', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'desk', 'keyboard', 'table_cloth', 'stovefan', 'mat', 'mousepad', 'pillow', 'bench', 'oven', 'photoframe', 'bed', 'coffee_filter', 'wine', 'centerpiece', 'dresser', 'sink', 'table', 'tooth_paste', 'laser_pointer', 'teeth'] Task:Drink response:

{ walk to kitchen, walk to table, grab water glass and drink water }

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', 'jelly', 'freezer', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'food_chicken', 'desk', 'keyboard', 'computer', 'food_bacon', 'toaster', 'ceilinglamp', 'stovefan', 'faucet', 'mousepad', 'oil', 'wall', 'powersocket', 'oven', 'food_food', 'tray', 'doorjamb', 'coffee_pot', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light'] Task:Cook some food response: { thoughts : I walk in the kitchen, I open the fridge and remove the Chicken. I grab frying fan and put it on stove. I put chicken in the frying pan and I cook food., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_chicken>', '[GRAB] <food_chicken>', '[FIND] <pot>', '[GRAB] <pot>', '[FIND] <oven>', '[PUTBACK] <pot> <oven>', '[PUTBACK] <food_chicken> <oven>'] } Scene_Objects:['pot', 'freezer', 'walllamp', 'food_carrot', 'milk', 'drawing', 'knifeblock', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'food_chicken', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'mat', 'stereo', 'stovefan', 'faucet', 'mousepad', 'oil', 'pillow', 'wall', 'powersocket', 'bench', 'oven', 'food_food', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'napkin', 'light', 'table'] Task:Cook some food response:

{ Walk to the kitchen and open the fridge. From the fridge take some chicken and close the fridge. Walk to the table and put the chicken on the table. Plug in oven and put the chicken into the oven. }